Fix T60014: material link pref ignored
[blender.git] / source / blender / editors / render / render_shading.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software Foundation,
15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16  *
17  * The Original Code is Copyright (C) 2009 Blender Foundation.
18  * All rights reserved.
19  *
20  * Contributor(s): Blender Foundation
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/render/render_shading.c
26  *  \ingroup edrend
27  */
28
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_curve_types.h"
35 #include "DNA_lamp_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_node_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_particle_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_world_types.h"
43
44 #include "BLI_utildefines.h"
45 #include "BLI_listbase.h"
46 #include "BLI_math_vector.h"
47
48 #include "BLT_translation.h"
49
50 #include "BKE_animsys.h"
51 #include "BKE_context.h"
52 #include "BKE_curve.h"
53 #include "BKE_depsgraph.h"
54 #include "BKE_font.h"
55 #include "BKE_global.h"
56 #include "BKE_image.h"
57 #include "BKE_library.h"
58 #include "BKE_linestyle.h"
59 #include "BKE_main.h"
60 #include "BKE_material.h"
61 #include "BKE_paint.h"
62 #include "BKE_report.h"
63 #include "BKE_scene.h"
64 #include "BKE_texture.h"
65 #include "BKE_world.h"
66 #include "BKE_editmesh.h"
67
68
69
70 #ifdef WITH_FREESTYLE
71 #  include "BKE_freestyle.h"
72 #  include "FRS_freestyle.h"
73 #  include "RNA_enum_types.h"
74 #endif
75
76 #include "RNA_access.h"
77
78 #include "WM_api.h"
79 #include "WM_types.h"
80
81 #include "ED_object.h"
82 #include "ED_curve.h"
83 #include "ED_mesh.h"
84 #include "ED_node.h"
85 #include "ED_render.h"
86 #include "ED_screen.h"
87
88 #include "RNA_define.h"
89
90 #include "UI_interface.h"
91
92 #include "RE_pipeline.h"
93
94 #include "render_intern.h"  // own include
95
96 /********************** material slot operators *********************/
97
98 static int material_slot_add_exec(bContext *C, wmOperator *UNUSED(op))
99 {
100         Main *bmain = CTX_data_main(C);
101         Object *ob = ED_object_context(C);
102
103         if (!ob)
104                 return OPERATOR_CANCELLED;
105
106         BKE_object_material_slot_add(bmain, ob);
107
108         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
109                 Scene *scene = CTX_data_scene(C);
110                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
111                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
112         }
113
114         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
115         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
116         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
117
118         return OPERATOR_FINISHED;
119 }
120
121 void OBJECT_OT_material_slot_add(wmOperatorType *ot)
122 {
123         /* identifiers */
124         ot->name = "Add Material Slot";
125         ot->idname = "OBJECT_OT_material_slot_add";
126         ot->description = "Add a new material slot";
127
128         /* api callbacks */
129         ot->exec = material_slot_add_exec;
130         ot->poll = ED_operator_object_active_editable;
131
132         /* flags */
133         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
134 }
135
136 static int material_slot_remove_exec(bContext *C, wmOperator *op)
137 {
138         Object *ob = ED_object_context(C);
139
140         if (!ob)
141                 return OPERATOR_CANCELLED;
142
143         /* Removing material slots in edit mode screws things up, see bug #21822.*/
144         if (ob == CTX_data_edit_object(C)) {
145                 BKE_report(op->reports, RPT_ERROR, "Unable to remove material slot in edit mode");
146                 return OPERATOR_CANCELLED;
147         }
148
149         BKE_object_material_slot_remove(CTX_data_main(C), ob);
150
151         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
152                 Scene *scene = CTX_data_scene(C);
153                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
154                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
155         }
156
157         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
158         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
159         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
160         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
161
162         return OPERATOR_FINISHED;
163 }
164
165 void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
166 {
167         /* identifiers */
168         ot->name = "Remove Material Slot";
169         ot->idname = "OBJECT_OT_material_slot_remove";
170         ot->description = "Remove the selected material slot";
171
172         /* api callbacks */
173         ot->exec = material_slot_remove_exec;
174         ot->poll = ED_operator_object_active_editable;
175
176         /* flags */
177         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
178 }
179
180 static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
181 {
182         Object *ob = ED_object_context(C);
183
184         if (!ob)
185                 return OPERATOR_CANCELLED;
186
187         if (ob && ob->actcol > 0) {
188                 if (ob->type == OB_MESH) {
189                         BMEditMesh *em = BKE_editmesh_from_object(ob);
190                         BMFace *efa;
191                         BMIter iter;
192
193                         if (em) {
194                                 BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
195                                         if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
196                                                 efa->mat_nr = ob->actcol - 1;
197                                 }
198                         }
199                 }
200                 else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
201                         Nurb *nu;
202                         ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
203
204                         if (nurbs) {
205                                 for (nu = nurbs->first; nu; nu = nu->next) {
206                                         if (ED_curve_nurb_select_check(ob->data, nu)) {
207                                                 nu->mat_nr = ob->actcol - 1;
208                                         }
209                                 }
210                         }
211                 }
212                 else if (ob->type == OB_FONT) {
213                         EditFont *ef = ((Curve *)ob->data)->editfont;
214                         int i, selstart, selend;
215
216                         if (ef && BKE_vfont_select_get(ob, &selstart, &selend)) {
217                                 for (i = selstart; i <= selend; i++)
218                                         ef->textbufinfo[i].mat_nr = ob->actcol;
219                         }
220                 }
221         }
222
223         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
224         WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
225
226         return OPERATOR_FINISHED;
227 }
228
229 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
230 {
231         /* identifiers */
232         ot->name = "Assign Material Slot";
233         ot->idname = "OBJECT_OT_material_slot_assign";
234         ot->description = "Assign active material slot to selection";
235
236         /* api callbacks */
237         ot->exec = material_slot_assign_exec;
238         ot->poll = ED_operator_object_active_editable;
239
240         /* flags */
241         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
242 }
243
244 static int material_slot_de_select(bContext *C, bool select)
245 {
246         Object *ob = ED_object_context(C);
247
248         if (!ob)
249                 return OPERATOR_CANCELLED;
250
251         if (ob->type == OB_MESH) {
252                 BMEditMesh *em = BKE_editmesh_from_object(ob);
253
254                 if (em) {
255                         EDBM_deselect_by_material(em, ob->actcol - 1, select);
256                 }
257         }
258         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
259                 ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
260                 Nurb *nu;
261                 BPoint *bp;
262                 BezTriple *bezt;
263                 int a;
264
265                 if (nurbs) {
266                         for (nu = nurbs->first; nu; nu = nu->next) {
267                                 if (nu->mat_nr == ob->actcol - 1) {
268                                         if (nu->bezt) {
269                                                 a = nu->pntsu;
270                                                 bezt = nu->bezt;
271                                                 while (a--) {
272                                                         if (bezt->hide == 0) {
273                                                                 if (select) {
274                                                                         bezt->f1 |= SELECT;
275                                                                         bezt->f2 |= SELECT;
276                                                                         bezt->f3 |= SELECT;
277                                                                 }
278                                                                 else {
279                                                                         bezt->f1 &= ~SELECT;
280                                                                         bezt->f2 &= ~SELECT;
281                                                                         bezt->f3 &= ~SELECT;
282                                                                 }
283                                                         }
284                                                         bezt++;
285                                                 }
286                                         }
287                                         else if (nu->bp) {
288                                                 a = nu->pntsu * nu->pntsv;
289                                                 bp = nu->bp;
290                                                 while (a--) {
291                                                         if (bp->hide == 0) {
292                                                                 if (select) bp->f1 |= SELECT;
293                                                                 else bp->f1 &= ~SELECT;
294                                                         }
295                                                         bp++;
296                                                 }
297                                         }
298                                 }
299                         }
300                 }
301         }
302
303         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
304
305         return OPERATOR_FINISHED;
306 }
307
308 static int material_slot_select_exec(bContext *C, wmOperator *UNUSED(op))
309 {
310         return material_slot_de_select(C, true);
311 }
312
313 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
314 {
315         /* identifiers */
316         ot->name = "Select Material Slot";
317         ot->idname = "OBJECT_OT_material_slot_select";
318         ot->description = "Select by active material slot";
319
320         /* api callbacks */
321         ot->exec = material_slot_select_exec;
322
323         /* flags */
324         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
325 }
326
327 static int material_slot_deselect_exec(bContext *C, wmOperator *UNUSED(op))
328 {
329         return material_slot_de_select(C, false);
330 }
331
332 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
333 {
334         /* identifiers */
335         ot->name = "Deselect Material Slot";
336         ot->idname = "OBJECT_OT_material_slot_deselect";
337         ot->description = "Deselect by active material slot";
338
339         /* api callbacks */
340         ot->exec = material_slot_deselect_exec;
341
342         /* flags */
343         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
344 }
345
346
347 static int material_slot_copy_exec(bContext *C, wmOperator *UNUSED(op))
348 {
349         Main *bmain = CTX_data_main(C);
350         Object *ob = ED_object_context(C);
351         Material ***matar;
352
353         if (!ob || !(matar = give_matarar(ob)))
354                 return OPERATOR_CANCELLED;
355
356         CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects)
357         {
358                 if (ob != ob_iter && give_matarar(ob_iter)) {
359                         if (ob->data != ob_iter->data)
360                                 assign_matarar(bmain, ob_iter, matar, ob->totcol);
361
362                         if (ob_iter->totcol == ob->totcol) {
363                                 ob_iter->actcol = ob->actcol;
364                                 DAG_id_tag_update(&ob_iter->id, OB_RECALC_DATA);
365                                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob_iter);
366                         }
367                 }
368         }
369         CTX_DATA_END;
370
371         return OPERATOR_FINISHED;
372 }
373
374
375 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
376 {
377         /* identifiers */
378         ot->name = "Copy Material to Others";
379         ot->idname = "OBJECT_OT_material_slot_copy";
380         ot->description = "Copies materials to other selected objects";
381
382         /* api callbacks */
383         ot->exec = material_slot_copy_exec;
384
385         /* flags */
386         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
387 }
388
389 static int material_slot_move_exec(bContext *C, wmOperator *op)
390 {
391         Object *ob = ED_object_context(C);
392
393         unsigned int *slot_remap;
394         int index_pair[2];
395
396         int dir = RNA_enum_get(op->ptr, "direction");
397
398         if (!ob || ob->totcol < 2) {
399                 return OPERATOR_CANCELLED;
400         }
401
402         /* up */
403         if (dir == 1 && ob->actcol > 1) {
404                 index_pair[0] = ob->actcol - 2;
405                 index_pair[1] = ob->actcol - 1;
406                 ob->actcol--;
407         }
408         /* down */
409         else if (dir == -1 && ob->actcol < ob->totcol) {
410                 index_pair[0] = ob->actcol - 1;
411                 index_pair[1] = ob->actcol - 0;
412                 ob->actcol++;
413         }
414         else {
415                 return OPERATOR_CANCELLED;
416         }
417
418         slot_remap = MEM_mallocN(sizeof(unsigned int) * ob->totcol, __func__);
419
420         range_vn_u(slot_remap, ob->totcol, 0);
421
422         slot_remap[index_pair[0]] = index_pair[1];
423         slot_remap[index_pair[1]] = index_pair[0];
424
425         BKE_material_remap_object(ob, slot_remap);
426
427         MEM_freeN(slot_remap);
428
429         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
430         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
431         WM_event_add_notifier(C, NC_OBJECT | ND_DATA, ob);
432
433         return OPERATOR_FINISHED;
434 }
435
436 void OBJECT_OT_material_slot_move(wmOperatorType *ot)
437 {
438         static const EnumPropertyItem material_slot_move[] = {
439                 {1, "UP", 0, "Up", ""},
440                 {-1, "DOWN", 0, "Down", ""},
441                 {0, NULL, 0, NULL, NULL}
442         };
443
444         /* identifiers */
445         ot->name = "Move Material";
446         ot->idname = "OBJECT_OT_material_slot_move";
447         ot->description = "Move the active material up/down in the list";
448
449         /* api callbacks */
450         ot->exec = material_slot_move_exec;
451
452         /* flags */
453         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
454
455         RNA_def_enum(ot->srna, "direction", material_slot_move, 0, "Direction",
456                      "Direction to move the active material towards");
457 }
458
459 /********************** new material operator *********************/
460
461 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
462 {
463         Scene *scene = CTX_data_scene(C);
464         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
465         Main *bmain = CTX_data_main(C);
466         PointerRNA ptr, idptr;
467         PropertyRNA *prop;
468
469         /* add or copy material */
470         if (ma) {
471                 ma = BKE_material_copy(bmain, ma);
472         }
473         else {
474                 ma = BKE_material_add(bmain, DATA_("Material"));
475
476                 if (BKE_scene_use_new_shading_nodes(scene)) {
477                         ED_node_shader_default(C, &ma->id);
478                         ma->use_nodes = true;
479                 }
480         }
481
482         /* hook into UI */
483         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
484
485         if (prop) {
486                 if (RNA_struct_is_a(ptr.type, &RNA_Object)) {
487                         /* Add slot follows user-preferences for creating new slots,
488                          * RNA pointer assignment doesn't, see: T60014. */
489                         Object *ob = ptr.data;
490                         if (give_current_material_p(ob, ob->actcol) == NULL) {
491                                 BKE_object_material_slot_add(bmain, ob);
492                         }
493                 }
494
495                 /* when creating new ID blocks, use is already 1, but RNA
496                  * pointer use also increases user, so this compensates it */
497                 id_us_min(&ma->id);
498
499                 RNA_id_pointer_create(&ma->id, &idptr);
500                 RNA_property_pointer_set(&ptr, prop, idptr);
501                 RNA_property_update(C, &ptr, prop);
502         }
503
504         WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
505
506         return OPERATOR_FINISHED;
507 }
508
509 void MATERIAL_OT_new(wmOperatorType *ot)
510 {
511         /* identifiers */
512         ot->name = "New Material";
513         ot->idname = "MATERIAL_OT_new";
514         ot->description = "Add a new material";
515
516         /* api callbacks */
517         ot->exec = new_material_exec;
518
519         /* flags */
520         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
521 }
522
523 /********************** new texture operator *********************/
524
525 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
526 {
527         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
528         Main *bmain = CTX_data_main(C);
529         PointerRNA ptr, idptr;
530         PropertyRNA *prop;
531
532         /* add or copy texture */
533         if (tex) {
534                 tex = BKE_texture_copy(bmain, tex);
535         }
536         else {
537                 tex = BKE_texture_add(bmain, DATA_("Texture"));
538         }
539
540         /* hook into UI */
541         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
542
543         if (prop) {
544                 /* when creating new ID blocks, use is already 1, but RNA
545                  * pointer use also increases user, so this compensates it */
546                 id_us_min(&tex->id);
547
548                 if (ptr.id.data && GS(((ID *)ptr.id.data)->name) == ID_MA &&
549                     RNA_property_pointer_get(&ptr, prop).id.data == NULL)
550                 {
551                         /* In case we are assigning new texture to a material, and active slot was empty, reset 'use' flag. */
552                         Material *ma = (Material *)ptr.id.data;
553                         ma->septex &= ~(1 << ma->texact);
554                 }
555
556                 RNA_id_pointer_create(&tex->id, &idptr);
557                 RNA_property_pointer_set(&ptr, prop, idptr);
558                 RNA_property_update(C, &ptr, prop);
559         }
560
561         WM_event_add_notifier(C, NC_TEXTURE | NA_ADDED, tex);
562
563         return OPERATOR_FINISHED;
564 }
565
566 void TEXTURE_OT_new(wmOperatorType *ot)
567 {
568         /* identifiers */
569         ot->name = "New Texture";
570         ot->idname = "TEXTURE_OT_new";
571         ot->description = "Add a new texture";
572
573         /* api callbacks */
574         ot->exec = new_texture_exec;
575
576         /* flags */
577         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
578 }
579
580 /********************** new world operator *********************/
581
582 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
583 {
584         Scene *scene = CTX_data_scene(C);
585         World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
586         Main *bmain = CTX_data_main(C);
587         PointerRNA ptr, idptr;
588         PropertyRNA *prop;
589
590         /* add or copy world */
591         if (wo) {
592                 wo = BKE_world_copy(bmain, wo);
593         }
594         else {
595                 wo = BKE_world_add(bmain, DATA_("World"));
596
597                 if (BKE_scene_use_new_shading_nodes(scene)) {
598                         ED_node_shader_default(C, &wo->id);
599                         wo->use_nodes = true;
600                 }
601         }
602
603         /* hook into UI */
604         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
605
606         if (prop) {
607                 /* when creating new ID blocks, use is already 1, but RNA
608                  * pointer use also increases user, so this compensates it */
609                 id_us_min(&wo->id);
610
611                 RNA_id_pointer_create(&wo->id, &idptr);
612                 RNA_property_pointer_set(&ptr, prop, idptr);
613                 RNA_property_update(C, &ptr, prop);
614         }
615
616         WM_event_add_notifier(C, NC_WORLD | NA_ADDED, wo);
617
618         return OPERATOR_FINISHED;
619 }
620
621 void WORLD_OT_new(wmOperatorType *ot)
622 {
623         /* identifiers */
624         ot->name = "New World";
625         ot->idname = "WORLD_OT_new";
626         ot->description = "Create a new world Data-Block";
627
628         /* api callbacks */
629         ot->exec = new_world_exec;
630
631         /* flags */
632         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
633 }
634
635 /********************** render layer operators *********************/
636
637 static int render_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
638 {
639         Scene *scene = CTX_data_scene(C);
640
641         BKE_scene_add_render_layer(scene, NULL);
642         scene->r.actlay = BLI_listbase_count(&scene->r.layers) - 1;
643
644         DAG_id_tag_update(&scene->id, 0);
645         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
646
647         return OPERATOR_FINISHED;
648 }
649
650 void SCENE_OT_render_layer_add(wmOperatorType *ot)
651 {
652         /* identifiers */
653         ot->name = "Add Render Layer";
654         ot->idname = "SCENE_OT_render_layer_add";
655         ot->description = "Add a render layer";
656
657         /* api callbacks */
658         ot->exec = render_layer_add_exec;
659
660         /* flags */
661         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
662 }
663
664 static int render_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
665 {
666         Scene *scene = CTX_data_scene(C);
667         SceneRenderLayer *rl = BLI_findlink(&scene->r.layers, scene->r.actlay);
668
669         if (!BKE_scene_remove_render_layer(CTX_data_main(C), scene, rl))
670                 return OPERATOR_CANCELLED;
671
672         DAG_id_tag_update(&scene->id, 0);
673         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
674
675         return OPERATOR_FINISHED;
676 }
677
678 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
679 {
680         /* identifiers */
681         ot->name = "Remove Render Layer";
682         ot->idname = "SCENE_OT_render_layer_remove";
683         ot->description = "Remove the selected render layer";
684
685         /* api callbacks */
686         ot->exec = render_layer_remove_exec;
687
688         /* flags */
689         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
690 }
691
692 /********************** render view operators *********************/
693
694 static bool render_view_remove_poll(bContext *C)
695 {
696         Scene *scene = CTX_data_scene(C);
697
698         /* don't allow user to remove "left" and "right" views */
699         return scene->r.actview > 1;
700 }
701
702 static int render_view_add_exec(bContext *C, wmOperator *UNUSED(op))
703 {
704         Scene *scene = CTX_data_scene(C);
705
706         BKE_scene_add_render_view(scene, NULL);
707         scene->r.actview = BLI_listbase_count(&scene->r.views) - 1;
708
709         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
710
711         return OPERATOR_FINISHED;
712 }
713
714 void SCENE_OT_render_view_add(wmOperatorType *ot)
715 {
716         /* identifiers */
717         ot->name = "Add Render View";
718         ot->idname = "SCENE_OT_render_view_add";
719         ot->description = "Add a render view";
720
721         /* api callbacks */
722         ot->exec = render_view_add_exec;
723
724         /* flags */
725         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
726 }
727
728 static int render_view_remove_exec(bContext *C, wmOperator *UNUSED(op))
729 {
730         Scene *scene = CTX_data_scene(C);
731         SceneRenderView *rv = BLI_findlink(&scene->r.views, scene->r.actview);
732
733         if (!BKE_scene_remove_render_view(scene, rv))
734                 return OPERATOR_CANCELLED;
735
736         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
737
738         return OPERATOR_FINISHED;
739 }
740
741 void SCENE_OT_render_view_remove(wmOperatorType *ot)
742 {
743         /* identifiers */
744         ot->name = "Remove Render View";
745         ot->idname = "SCENE_OT_render_view_remove";
746         ot->description = "Remove the selected render view";
747
748         /* api callbacks */
749         ot->exec = render_view_remove_exec;
750         ot->poll = render_view_remove_poll;
751
752         /* flags */
753         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
754 }
755
756 #ifdef WITH_FREESTYLE
757
758 static bool freestyle_linestyle_check_report(FreestyleLineSet *lineset, ReportList *reports)
759 {
760         if (!lineset) {
761                 BKE_report(reports, RPT_ERROR, "No active lineset and associated line style to manipulate the modifier");
762                 return false;
763         }
764         if (!lineset->linestyle) {
765                 BKE_report(reports, RPT_ERROR, "The active lineset does not have a line style (indicating data corruption)");
766                 return false;
767         }
768
769         return true;
770 }
771
772 static bool freestyle_active_module_poll(bContext *C)
773 {
774         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
775         FreestyleModuleConfig *module = ptr.data;
776
777         return module != NULL;
778 }
779
780 static int freestyle_module_add_exec(bContext *C, wmOperator *UNUSED(op))
781 {
782         Scene *scene = CTX_data_scene(C);
783         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
784
785         BKE_freestyle_module_add(&srl->freestyleConfig);
786
787         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
788
789         return OPERATOR_FINISHED;
790 }
791
792 void SCENE_OT_freestyle_module_add(wmOperatorType *ot)
793 {
794         /* identifiers */
795         ot->name = "Add Freestyle Module";
796         ot->idname = "SCENE_OT_freestyle_module_add";
797         ot->description = "Add a style module into the list of modules";
798
799         /* api callbacks */
800         ot->exec = freestyle_module_add_exec;
801
802         /* flags */
803         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
804 }
805
806 static int freestyle_module_remove_exec(bContext *C, wmOperator *UNUSED(op))
807 {
808         Scene *scene = CTX_data_scene(C);
809         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
810         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
811         FreestyleModuleConfig *module = ptr.data;
812
813         BKE_freestyle_module_delete(&srl->freestyleConfig, module);
814
815         DAG_id_tag_update(&scene->id, 0);
816         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
817
818         return OPERATOR_FINISHED;
819 }
820
821 void SCENE_OT_freestyle_module_remove(wmOperatorType *ot)
822 {
823         /* identifiers */
824         ot->name = "Remove Freestyle Module";
825         ot->idname = "SCENE_OT_freestyle_module_remove";
826         ot->description = "Remove the style module from the stack";
827
828         /* api callbacks */
829         ot->poll = freestyle_active_module_poll;
830         ot->exec = freestyle_module_remove_exec;
831
832         /* flags */
833         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
834 }
835
836 static int freestyle_module_move_exec(bContext *C, wmOperator *op)
837 {
838         Scene *scene = CTX_data_scene(C);
839         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
840         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
841         FreestyleModuleConfig *module = ptr.data;
842         int dir = RNA_enum_get(op->ptr, "direction");
843
844         if (BKE_freestyle_module_move(&srl->freestyleConfig, module, dir)) {
845                 DAG_id_tag_update(&scene->id, 0);
846                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
847         }
848
849         return OPERATOR_FINISHED;
850 }
851
852 void SCENE_OT_freestyle_module_move(wmOperatorType *ot)
853 {
854         static const EnumPropertyItem direction_items[] = {
855                 {-1, "UP", 0, "Up", ""},
856                 {1, "DOWN", 0, "Down", ""},
857                 {0, NULL, 0, NULL, NULL}
858         };
859
860         /* identifiers */
861         ot->name = "Move Freestyle Module";
862         ot->idname = "SCENE_OT_freestyle_module_move";
863         ot->description = "Change the position of the style module within in the list of style modules";
864
865         /* api callbacks */
866         ot->poll = freestyle_active_module_poll;
867         ot->exec = freestyle_module_move_exec;
868
869         /* flags */
870         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
871
872         /* props */
873         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
874                      "Direction to move the chosen style module towards");
875 }
876
877 static int freestyle_lineset_add_exec(bContext *C, wmOperator *UNUSED(op))
878 {
879         Main *bmain = CTX_data_main(C);
880         Scene *scene = CTX_data_scene(C);
881         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
882
883         BKE_freestyle_lineset_add(bmain, &srl->freestyleConfig, NULL);
884
885         DAG_id_tag_update(&scene->id, 0);
886         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
887
888         return OPERATOR_FINISHED;
889 }
890
891 void SCENE_OT_freestyle_lineset_add(wmOperatorType *ot)
892 {
893         /* identifiers */
894         ot->name = "Add Line Set";
895         ot->idname = "SCENE_OT_freestyle_lineset_add";
896         ot->description = "Add a line set into the list of line sets";
897
898         /* api callbacks */
899         ot->exec = freestyle_lineset_add_exec;
900
901         /* flags */
902         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
903 }
904
905 static bool freestyle_active_lineset_poll(bContext *C)
906 {
907         Scene *scene = CTX_data_scene(C);
908         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
909
910         if (!srl) {
911                 return false;
912         }
913
914         return BKE_freestyle_lineset_get_active(&srl->freestyleConfig) != NULL;
915 }
916
917 static int freestyle_lineset_copy_exec(bContext *C, wmOperator *UNUSED(op))
918 {
919         Scene *scene = CTX_data_scene(C);
920         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
921
922         FRS_copy_active_lineset(&srl->freestyleConfig);
923
924         return OPERATOR_FINISHED;
925 }
926
927 void SCENE_OT_freestyle_lineset_copy(wmOperatorType *ot)
928 {
929         /* identifiers */
930         ot->name = "Copy Line Set";
931         ot->idname = "SCENE_OT_freestyle_lineset_copy";
932         ot->description = "Copy the active line set to a buffer";
933
934         /* api callbacks */
935         ot->exec = freestyle_lineset_copy_exec;
936         ot->poll = freestyle_active_lineset_poll;
937
938         /* flags */
939         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
940 }
941
942 static int freestyle_lineset_paste_exec(bContext *C, wmOperator *UNUSED(op))
943 {
944         Scene *scene = CTX_data_scene(C);
945         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
946
947         FRS_paste_active_lineset(&srl->freestyleConfig);
948
949         DAG_id_tag_update(&scene->id, 0);
950         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
951
952         return OPERATOR_FINISHED;
953 }
954
955 void SCENE_OT_freestyle_lineset_paste(wmOperatorType *ot)
956 {
957         /* identifiers */
958         ot->name = "Paste Line Set";
959         ot->idname = "SCENE_OT_freestyle_lineset_paste";
960         ot->description = "Paste the buffer content to the active line set";
961
962         /* api callbacks */
963         ot->exec = freestyle_lineset_paste_exec;
964         ot->poll = freestyle_active_lineset_poll;
965
966         /* flags */
967         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
968 }
969
970 static int freestyle_lineset_remove_exec(bContext *C, wmOperator *UNUSED(op))
971 {
972         Scene *scene = CTX_data_scene(C);
973         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
974
975         FRS_delete_active_lineset(&srl->freestyleConfig);
976
977         DAG_id_tag_update(&scene->id, 0);
978         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
979
980         return OPERATOR_FINISHED;
981 }
982
983 void SCENE_OT_freestyle_lineset_remove(wmOperatorType *ot)
984 {
985         /* identifiers */
986         ot->name = "Remove Line Set";
987         ot->idname = "SCENE_OT_freestyle_lineset_remove";
988         ot->description = "Remove the active line set from the list of line sets";
989
990         /* api callbacks */
991         ot->exec = freestyle_lineset_remove_exec;
992         ot->poll = freestyle_active_lineset_poll;
993
994         /* flags */
995         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
996 }
997
998 static int freestyle_lineset_move_exec(bContext *C, wmOperator *op)
999 {
1000         Scene *scene = CTX_data_scene(C);
1001         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1002         int dir = RNA_enum_get(op->ptr, "direction");
1003
1004         if (FRS_move_active_lineset(&srl->freestyleConfig, dir)) {
1005                 DAG_id_tag_update(&scene->id, 0);
1006                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
1007         }
1008
1009         return OPERATOR_FINISHED;
1010 }
1011
1012 void SCENE_OT_freestyle_lineset_move(wmOperatorType *ot)
1013 {
1014         static const EnumPropertyItem direction_items[] = {
1015                 {-1, "UP", 0, "Up", ""},
1016                 {1, "DOWN", 0, "Down", ""},
1017                 {0, NULL, 0, NULL, NULL}
1018         };
1019
1020         /* identifiers */
1021         ot->name = "Move Line Set";
1022         ot->idname = "SCENE_OT_freestyle_lineset_move";
1023         ot->description = "Change the position of the active line set within the list of line sets";
1024
1025         /* api callbacks */
1026         ot->exec = freestyle_lineset_move_exec;
1027         ot->poll = freestyle_active_lineset_poll;
1028
1029         /* flags */
1030         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1031
1032         /* props */
1033         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1034                      "Direction to move the active line set towards");
1035 }
1036
1037 static int freestyle_linestyle_new_exec(bContext *C, wmOperator *op)
1038 {
1039         Main *bmain = CTX_data_main(C);
1040         Scene *scene = CTX_data_scene(C);
1041         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1042         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1043
1044         if (!lineset) {
1045                 BKE_report(op->reports, RPT_ERROR, "No active lineset to add a new line style to");
1046                 return OPERATOR_CANCELLED;
1047         }
1048         if (lineset->linestyle) {
1049                 id_us_min(&lineset->linestyle->id);
1050                 lineset->linestyle = BKE_linestyle_copy(bmain, lineset->linestyle);
1051         }
1052         else {
1053                 lineset->linestyle = BKE_linestyle_new(bmain, "LineStyle");
1054         }
1055         DAG_id_tag_update(&lineset->linestyle->id, 0);
1056         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1057
1058         return OPERATOR_FINISHED;
1059 }
1060
1061 void SCENE_OT_freestyle_linestyle_new(wmOperatorType *ot)
1062 {
1063         /* identifiers */
1064         ot->name = "New Line Style";
1065         ot->idname = "SCENE_OT_freestyle_linestyle_new";
1066         ot->description = "Create a new line style, reusable by multiple line sets";
1067
1068         /* api callbacks */
1069         ot->exec = freestyle_linestyle_new_exec;
1070         ot->poll = freestyle_active_lineset_poll;
1071
1072         /* flags */
1073         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1074 }
1075
1076 static int freestyle_color_modifier_add_exec(bContext *C, wmOperator *op)
1077 {
1078         Scene *scene = CTX_data_scene(C);
1079         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1080         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1081         int type = RNA_enum_get(op->ptr, "type");
1082
1083         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1084                 return OPERATOR_CANCELLED;
1085         }
1086
1087         if (BKE_linestyle_color_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1088                 BKE_report(op->reports, RPT_ERROR, "Unknown line color modifier type");
1089                 return OPERATOR_CANCELLED;
1090         }
1091         DAG_id_tag_update(&lineset->linestyle->id, 0);
1092         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1093
1094         return OPERATOR_FINISHED;
1095 }
1096
1097 void SCENE_OT_freestyle_color_modifier_add(wmOperatorType *ot)
1098 {
1099         /* identifiers */
1100         ot->name = "Add Line Color Modifier";
1101         ot->idname = "SCENE_OT_freestyle_color_modifier_add";
1102         ot->description = "Add a line color modifier to the line style associated with the active lineset";
1103
1104         /* api callbacks */
1105         ot->invoke = WM_menu_invoke;
1106         ot->exec = freestyle_color_modifier_add_exec;
1107         ot->poll = freestyle_active_lineset_poll;
1108
1109         /* flags */
1110         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1111
1112         /* properties */
1113         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_color_modifier_type_items, 0, "Type", "");
1114 }
1115
1116 static int freestyle_alpha_modifier_add_exec(bContext *C, wmOperator *op)
1117 {
1118         Scene *scene = CTX_data_scene(C);
1119         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1120         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1121         int type = RNA_enum_get(op->ptr, "type");
1122
1123         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1124                 return OPERATOR_CANCELLED;
1125         }
1126
1127         if (BKE_linestyle_alpha_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1128                 BKE_report(op->reports, RPT_ERROR, "Unknown alpha transparency modifier type");
1129                 return OPERATOR_CANCELLED;
1130         }
1131         DAG_id_tag_update(&lineset->linestyle->id, 0);
1132         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1133
1134         return OPERATOR_FINISHED;
1135 }
1136
1137 void SCENE_OT_freestyle_alpha_modifier_add(wmOperatorType *ot)
1138 {
1139         /* identifiers */
1140         ot->name = "Add Alpha Transparency Modifier";
1141         ot->idname = "SCENE_OT_freestyle_alpha_modifier_add";
1142         ot->description = "Add an alpha transparency modifier to the line style associated with the active lineset";
1143
1144         /* api callbacks */
1145         ot->invoke = WM_menu_invoke;
1146         ot->exec = freestyle_alpha_modifier_add_exec;
1147         ot->poll = freestyle_active_lineset_poll;
1148
1149         /* flags */
1150         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1151
1152         /* properties */
1153         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_alpha_modifier_type_items, 0, "Type", "");
1154 }
1155
1156 static int freestyle_thickness_modifier_add_exec(bContext *C, wmOperator *op)
1157 {
1158         Scene *scene = CTX_data_scene(C);
1159         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1160         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1161         int type = RNA_enum_get(op->ptr, "type");
1162
1163         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1164                 return OPERATOR_CANCELLED;
1165         }
1166
1167         if (BKE_linestyle_thickness_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1168                 BKE_report(op->reports, RPT_ERROR, "Unknown line thickness modifier type");
1169                 return OPERATOR_CANCELLED;
1170         }
1171         DAG_id_tag_update(&lineset->linestyle->id, 0);
1172         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1173
1174         return OPERATOR_FINISHED;
1175 }
1176
1177 void SCENE_OT_freestyle_thickness_modifier_add(wmOperatorType *ot)
1178 {
1179         /* identifiers */
1180         ot->name = "Add Line Thickness Modifier";
1181         ot->idname = "SCENE_OT_freestyle_thickness_modifier_add";
1182         ot->description = "Add a line thickness modifier to the line style associated with the active lineset";
1183
1184         /* api callbacks */
1185         ot->invoke = WM_menu_invoke;
1186         ot->exec = freestyle_thickness_modifier_add_exec;
1187         ot->poll = freestyle_active_lineset_poll;
1188
1189         /* flags */
1190         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1191
1192         /* properties */
1193         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_thickness_modifier_type_items, 0, "Type", "");
1194 }
1195
1196 static int freestyle_geometry_modifier_add_exec(bContext *C, wmOperator *op)
1197 {
1198         Scene *scene = CTX_data_scene(C);
1199         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1200         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1201         int type = RNA_enum_get(op->ptr, "type");
1202
1203         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1204                 return OPERATOR_CANCELLED;
1205         }
1206
1207         if (BKE_linestyle_geometry_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1208                 BKE_report(op->reports, RPT_ERROR, "Unknown stroke geometry modifier type");
1209                 return OPERATOR_CANCELLED;
1210         }
1211         DAG_id_tag_update(&lineset->linestyle->id, 0);
1212         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1213
1214         return OPERATOR_FINISHED;
1215 }
1216
1217 void SCENE_OT_freestyle_geometry_modifier_add(wmOperatorType *ot)
1218 {
1219         /* identifiers */
1220         ot->name = "Add Stroke Geometry Modifier";
1221         ot->idname = "SCENE_OT_freestyle_geometry_modifier_add";
1222         ot->description = "Add a stroke geometry modifier to the line style associated with the active lineset";
1223
1224         /* api callbacks */
1225         ot->invoke = WM_menu_invoke;
1226         ot->exec = freestyle_geometry_modifier_add_exec;
1227         ot->poll = freestyle_active_lineset_poll;
1228
1229         /* flags */
1230         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1231
1232         /* properties */
1233         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_geometry_modifier_type_items, 0, "Type", "");
1234 }
1235
1236 static int freestyle_get_modifier_type(PointerRNA *ptr)
1237 {
1238         if (RNA_struct_is_a(ptr->type, &RNA_LineStyleColorModifier))
1239                 return LS_MODIFIER_TYPE_COLOR;
1240         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleAlphaModifier))
1241                 return LS_MODIFIER_TYPE_ALPHA;
1242         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleThicknessModifier))
1243                 return LS_MODIFIER_TYPE_THICKNESS;
1244         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleGeometryModifier))
1245                 return LS_MODIFIER_TYPE_GEOMETRY;
1246         return -1;
1247 }
1248
1249 static int freestyle_modifier_remove_exec(bContext *C, wmOperator *op)
1250 {
1251         Scene *scene = CTX_data_scene(C);
1252         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1253         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1254         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1255         LineStyleModifier *modifier = ptr.data;
1256
1257         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1258                 return OPERATOR_CANCELLED;
1259         }
1260
1261         switch (freestyle_get_modifier_type(&ptr)) {
1262                 case LS_MODIFIER_TYPE_COLOR:
1263                         BKE_linestyle_color_modifier_remove(lineset->linestyle, modifier);
1264                         break;
1265                 case LS_MODIFIER_TYPE_ALPHA:
1266                         BKE_linestyle_alpha_modifier_remove(lineset->linestyle, modifier);
1267                         break;
1268                 case LS_MODIFIER_TYPE_THICKNESS:
1269                         BKE_linestyle_thickness_modifier_remove(lineset->linestyle, modifier);
1270                         break;
1271                 case LS_MODIFIER_TYPE_GEOMETRY:
1272                         BKE_linestyle_geometry_modifier_remove(lineset->linestyle, modifier);
1273                         break;
1274                 default:
1275                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1276                         return OPERATOR_CANCELLED;
1277         }
1278         DAG_id_tag_update(&lineset->linestyle->id, 0);
1279         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1280
1281         return OPERATOR_FINISHED;
1282 }
1283
1284 void SCENE_OT_freestyle_modifier_remove(wmOperatorType *ot)
1285 {
1286         /* identifiers */
1287         ot->name = "Remove Modifier";
1288         ot->idname = "SCENE_OT_freestyle_modifier_remove";
1289         ot->description = "Remove the modifier from the list of modifiers";
1290
1291         /* api callbacks */
1292         ot->exec = freestyle_modifier_remove_exec;
1293         ot->poll = freestyle_active_lineset_poll;
1294
1295         /* flags */
1296         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1297 }
1298
1299 static int freestyle_modifier_copy_exec(bContext *C, wmOperator *op)
1300 {
1301         Scene *scene = CTX_data_scene(C);
1302         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1303         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1304         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1305         LineStyleModifier *modifier = ptr.data;
1306
1307         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1308                 return OPERATOR_CANCELLED;
1309         }
1310
1311         switch (freestyle_get_modifier_type(&ptr)) {
1312                 case LS_MODIFIER_TYPE_COLOR:
1313                         BKE_linestyle_color_modifier_copy(lineset->linestyle, modifier, 0);
1314                         break;
1315                 case LS_MODIFIER_TYPE_ALPHA:
1316                         BKE_linestyle_alpha_modifier_copy(lineset->linestyle, modifier, 0);
1317                         break;
1318                 case LS_MODIFIER_TYPE_THICKNESS:
1319                         BKE_linestyle_thickness_modifier_copy(lineset->linestyle, modifier, 0);
1320                         break;
1321                 case LS_MODIFIER_TYPE_GEOMETRY:
1322                         BKE_linestyle_geometry_modifier_copy(lineset->linestyle, modifier, 0);
1323                         break;
1324                 default:
1325                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1326                         return OPERATOR_CANCELLED;
1327         }
1328         DAG_id_tag_update(&lineset->linestyle->id, 0);
1329         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1330
1331         return OPERATOR_FINISHED;
1332 }
1333
1334 void SCENE_OT_freestyle_modifier_copy(wmOperatorType *ot)
1335 {
1336         /* identifiers */
1337         ot->name = "Copy Modifier";
1338         ot->idname = "SCENE_OT_freestyle_modifier_copy";
1339         ot->description = "Duplicate the modifier within the list of modifiers";
1340
1341         /* api callbacks */
1342         ot->exec = freestyle_modifier_copy_exec;
1343         ot->poll = freestyle_active_lineset_poll;
1344
1345         /* flags */
1346         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1347 }
1348
1349 static int freestyle_modifier_move_exec(bContext *C, wmOperator *op)
1350 {
1351         Scene *scene = CTX_data_scene(C);
1352         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1353         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1354         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1355         LineStyleModifier *modifier = ptr.data;
1356         int dir = RNA_enum_get(op->ptr, "direction");
1357         bool changed = false;
1358
1359         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1360                 return OPERATOR_CANCELLED;
1361         }
1362
1363         switch (freestyle_get_modifier_type(&ptr)) {
1364                 case LS_MODIFIER_TYPE_COLOR:
1365                         changed = BKE_linestyle_color_modifier_move(lineset->linestyle, modifier, dir);
1366                         break;
1367                 case LS_MODIFIER_TYPE_ALPHA:
1368                         changed = BKE_linestyle_alpha_modifier_move(lineset->linestyle, modifier, dir);
1369                         break;
1370                 case LS_MODIFIER_TYPE_THICKNESS:
1371                         changed = BKE_linestyle_thickness_modifier_move(lineset->linestyle, modifier, dir);
1372                         break;
1373                 case LS_MODIFIER_TYPE_GEOMETRY:
1374                         changed = BKE_linestyle_geometry_modifier_move(lineset->linestyle, modifier, dir);
1375                         break;
1376                 default:
1377                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1378                         return OPERATOR_CANCELLED;
1379         }
1380
1381         if (changed) {
1382                 DAG_id_tag_update(&lineset->linestyle->id, 0);
1383                 WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1384         }
1385
1386         return OPERATOR_FINISHED;
1387 }
1388
1389 void SCENE_OT_freestyle_modifier_move(wmOperatorType *ot)
1390 {
1391         static const EnumPropertyItem direction_items[] = {
1392                 {-1, "UP", 0, "Up", ""},
1393                 {1, "DOWN", 0, "Down", ""},
1394                 {0, NULL, 0, NULL, NULL}
1395         };
1396
1397         /* identifiers */
1398         ot->name = "Move Modifier";
1399         ot->idname = "SCENE_OT_freestyle_modifier_move";
1400         ot->description = "Move the modifier within the list of modifiers";
1401
1402         /* api callbacks */
1403         ot->exec = freestyle_modifier_move_exec;
1404         ot->poll = freestyle_active_lineset_poll;
1405
1406         /* flags */
1407         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1408
1409         /* props */
1410         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1411                      "Direction to move the chosen modifier towards");
1412 }
1413
1414 static int freestyle_stroke_material_create_exec(bContext *C, wmOperator *op)
1415 {
1416         Main *bmain = CTX_data_main(C);
1417         Scene *scene = CTX_data_scene(C);
1418         FreestyleLineStyle *linestyle = BKE_linestyle_active_from_scene(scene);
1419
1420         if (!linestyle) {
1421                 BKE_report(op->reports, RPT_ERROR, "No active line style in the current scene");
1422                 return OPERATOR_CANCELLED;
1423         }
1424
1425         FRS_create_stroke_material(bmain, linestyle);
1426
1427         return OPERATOR_FINISHED;
1428 }
1429
1430 void SCENE_OT_freestyle_stroke_material_create(wmOperatorType *ot)
1431 {
1432         /* identifiers */
1433         ot->name = "Create Freestyle Stroke Material";
1434         ot->idname = "SCENE_OT_freestyle_stroke_material_create";
1435         ot->description = "Create Freestyle stroke material for testing";
1436
1437         /* api callbacks */
1438         ot->exec = freestyle_stroke_material_create_exec;
1439
1440         /* flags */
1441         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1442 }
1443
1444 #endif /* WITH_FREESTYLE */
1445
1446 static int texture_slot_move_exec(bContext *C, wmOperator *op)
1447 {
1448         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1449
1450         if (id) {
1451                 MTex **mtex_ar, *mtexswap;
1452                 short act;
1453                 int type = RNA_enum_get(op->ptr, "type");
1454                 struct AnimData *adt = BKE_animdata_from_id(id);
1455
1456                 give_active_mtex(id, &mtex_ar, &act);
1457
1458                 if (type == -1) { /* Up */
1459                         if (act > 0) {
1460                                 mtexswap = mtex_ar[act];
1461                                 mtex_ar[act] = mtex_ar[act - 1];
1462                                 mtex_ar[act - 1] = mtexswap;
1463
1464                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act - 1, -1, 0);
1465                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act - 1, 0);
1466                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1467
1468                                 if (GS(id->name) == ID_MA) {
1469                                         Material *ma = (Material *)id;
1470                                         int mtexuse = ma->septex & (1 << act);
1471                                         ma->septex &= ~(1 << act);
1472                                         ma->septex |= (ma->septex & (1 << (act - 1))) << 1;
1473                                         ma->septex &= ~(1 << (act - 1));
1474                                         ma->septex |= mtexuse >> 1;
1475                                 }
1476
1477                                 set_active_mtex(id, act - 1);
1478                         }
1479                 }
1480                 else { /* Down */
1481                         if (act < MAX_MTEX - 1) {
1482                                 mtexswap = mtex_ar[act];
1483                                 mtex_ar[act] = mtex_ar[act + 1];
1484                                 mtex_ar[act + 1] = mtexswap;
1485
1486                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act + 1, -1, 0);
1487                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act + 1, 0);
1488                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1489
1490                                 if (GS(id->name) == ID_MA) {
1491                                         Material *ma = (Material *)id;
1492                                         int mtexuse = ma->septex & (1 << act);
1493                                         ma->septex &= ~(1 << act);
1494                                         ma->septex |= (ma->septex & (1 << (act + 1))) >> 1;
1495                                         ma->septex &= ~(1 << (act + 1));
1496                                         ma->septex |= mtexuse << 1;
1497                                 }
1498
1499                                 set_active_mtex(id, act + 1);
1500                         }
1501                 }
1502
1503                 DAG_id_tag_update(id, 0);
1504                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
1505         }
1506
1507         return OPERATOR_FINISHED;
1508 }
1509
1510 void TEXTURE_OT_slot_move(wmOperatorType *ot)
1511 {
1512         static const EnumPropertyItem slot_move[] = {
1513                 {-1, "UP", 0, "Up", ""},
1514                 {1, "DOWN", 0, "Down", ""},
1515                 {0, NULL, 0, NULL, NULL}
1516         };
1517
1518         /* identifiers */
1519         ot->name = "Move Texture Slot";
1520         ot->idname = "TEXTURE_OT_slot_move";
1521         ot->description = "Move texture slots up and down";
1522
1523         /* api callbacks */
1524         ot->exec = texture_slot_move_exec;
1525
1526         /* flags */
1527         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1528
1529         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
1530 }
1531
1532
1533
1534 /********************** environment map operators *********************/
1535
1536 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
1537 {
1538         PropertyRNA *prop;
1539         float layout[12];
1540
1541         if ((prop = RNA_struct_find_property(op->ptr, "layout"))) {
1542                 RNA_property_float_get_array(op->ptr, prop, layout);
1543         }
1544         else {
1545                 memcpy(layout, default_envmap_layout, sizeof(layout));
1546         }
1547
1548         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
1549                 return OPERATOR_FINISHED;
1550         }
1551         else {
1552                 return OPERATOR_CANCELLED;
1553         }
1554
1555 }
1556
1557 static int envmap_save_exec(bContext *C, wmOperator *op)
1558 {
1559         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1560         Scene *scene = CTX_data_scene(C);
1561         //int imtype = RNA_enum_get(op->ptr, "file_type");
1562         char imtype = scene->r.im_format.imtype;
1563         char path[FILE_MAX];
1564
1565         RNA_string_get(op->ptr, "filepath", path);
1566
1567         if (scene->r.scemode & R_EXTENSION) {
1568                 BKE_image_path_ensure_ext_from_imformat(path, &scene->r.im_format);
1569         }
1570
1571         WM_cursor_wait(1);
1572
1573         save_envmap(op, scene, tex->env, path, imtype);
1574
1575         WM_cursor_wait(0);
1576
1577         WM_event_add_notifier(C, NC_TEXTURE, tex);
1578
1579         return OPERATOR_FINISHED;
1580 }
1581
1582 static int envmap_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1583 {
1584         Main *bmain = CTX_data_main(C);
1585         //Scene *scene= CTX_data_scene(C);
1586
1587         if (RNA_struct_property_is_set(op->ptr, "filepath"))
1588                 return envmap_save_exec(C, op);
1589
1590         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
1591         RNA_string_set(op->ptr, "filepath", BKE_main_blendfile_path(bmain));
1592         WM_event_add_fileselect(C, op);
1593
1594         return OPERATOR_RUNNING_MODAL;
1595 }
1596
1597 static bool envmap_save_poll(bContext *C)
1598 {
1599         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1600
1601         if (!tex)
1602                 return 0;
1603         if (!tex->env || !tex->env->ok)
1604                 return 0;
1605         if (tex->env->cube[1] == NULL)
1606                 return 0;
1607
1608         return 1;
1609 }
1610
1611 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
1612 {
1613         PropertyRNA *prop;
1614         /* identifiers */
1615         ot->name = "Save Environment Map";
1616         ot->idname = "TEXTURE_OT_envmap_save";
1617         ot->description = "Save the current generated Environment map to an image file";
1618
1619         /* api callbacks */
1620         ot->exec = envmap_save_exec;
1621         ot->invoke = envmap_save_invoke;
1622         ot->poll = envmap_save_poll;
1623
1624         /* flags */
1625         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo since this doesnt modify the env-map */
1626
1627         /* properties */
1628         prop = RNA_def_float_array(ot->srna, "layout", 12, default_envmap_layout, 0.0f, 0.0f,
1629                                    "File layout",
1630                                    "Flat array describing the X,Y position of each cube face in the output image, "
1631                                    "where 1 is the size of a face - order is [+Z -Z +Y -X -Y +X] "
1632                                    "(use -1 to skip a face)", 0.0f, 0.0f);
1633         RNA_def_property_flag(prop, PROP_HIDDEN);
1634
1635         WM_operator_properties_filesel(
1636                 ot, FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_SAVE,
1637                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
1638 }
1639
1640 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
1641 {
1642         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1643
1644         BKE_texture_envmap_free_data(tex->env);
1645
1646         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1647
1648         return OPERATOR_FINISHED;
1649 }
1650
1651 static bool envmap_clear_poll(bContext *C)
1652 {
1653         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1654
1655         if (!tex)
1656                 return 0;
1657         if (!tex->env || !tex->env->ok)
1658                 return 0;
1659         if (tex->env->cube[1] == NULL)
1660                 return 0;
1661
1662         return 1;
1663 }
1664
1665 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
1666 {
1667         /* identifiers */
1668         ot->name = "Clear Environment Map";
1669         ot->idname = "TEXTURE_OT_envmap_clear";
1670         ot->description = "Discard the environment map and free it from memory";
1671
1672         /* api callbacks */
1673         ot->exec = envmap_clear_exec;
1674         ot->poll = envmap_clear_poll;
1675
1676         /* flags */
1677         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1678 }
1679
1680 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
1681 {
1682         Main *bmain = CTX_data_main(C);
1683         Tex *tex;
1684
1685         for (tex = bmain->tex.first; tex; tex = tex->id.next)
1686                 if (tex->env)
1687                         BKE_texture_envmap_free_data(tex->env);
1688
1689         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1690
1691         return OPERATOR_FINISHED;
1692 }
1693
1694 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
1695 {
1696         /* identifiers */
1697         ot->name = "Clear All Environment Maps";
1698         ot->idname = "TEXTURE_OT_envmap_clear_all";
1699         ot->description = "Discard all environment maps in the .blend file and free them from memory";
1700
1701         /* api callbacks */
1702         ot->exec = envmap_clear_all_exec;
1703         ot->poll = envmap_clear_poll;
1704
1705         /* flags */
1706         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1707 }
1708
1709 /********************** material operators *********************/
1710
1711 /* material copy/paste */
1712 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
1713 {
1714         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1715
1716         if (ma == NULL)
1717                 return OPERATOR_CANCELLED;
1718
1719         copy_matcopybuf(CTX_data_main(C), ma);
1720
1721         return OPERATOR_FINISHED;
1722 }
1723
1724 void MATERIAL_OT_copy(wmOperatorType *ot)
1725 {
1726         /* identifiers */
1727         ot->name = "Copy Material";
1728         ot->idname = "MATERIAL_OT_copy";
1729         ot->description = "Copy the material settings and nodes";
1730
1731         /* api callbacks */
1732         ot->exec = copy_material_exec;
1733
1734         /* flags */
1735         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the material */
1736 }
1737
1738 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
1739 {
1740         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1741
1742         if (ma == NULL)
1743                 return OPERATOR_CANCELLED;
1744
1745         paste_matcopybuf(CTX_data_main(C), ma);
1746
1747         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
1748
1749         return OPERATOR_FINISHED;
1750 }
1751
1752 void MATERIAL_OT_paste(wmOperatorType *ot)
1753 {
1754         /* identifiers */
1755         ot->name = "Paste Material";
1756         ot->idname = "MATERIAL_OT_paste";
1757         ot->description = "Paste the material settings and nodes";
1758
1759         /* api callbacks */
1760         ot->exec = paste_material_exec;
1761
1762         /* flags */
1763         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1764 }
1765
1766
1767 static short mtexcopied = 0; /* must be reset on file load */
1768 static MTex mtexcopybuf;
1769
1770 void ED_render_clear_mtex_copybuf(void)
1771 {   /* use for file reload */
1772         mtexcopied = 0;
1773 }
1774
1775 static void copy_mtex_copybuf(ID *id)
1776 {
1777         MTex **mtex = NULL;
1778
1779         switch (GS(id->name)) {
1780                 case ID_MA:
1781                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1782                         break;
1783                 case ID_LA:
1784                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1785                         // la->mtex[(int)la->texact] // TODO
1786                         break;
1787                 case ID_WO:
1788                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1789                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1790                         break;
1791                 case ID_PA:
1792                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1793                         break;
1794                 case ID_LS:
1795                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1796                         break;
1797                 default:
1798                         break;
1799         }
1800
1801         if (mtex && *mtex) {
1802                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
1803                 mtexcopied = 1;
1804         }
1805         else {
1806                 mtexcopied = 0;
1807         }
1808 }
1809
1810 static void paste_mtex_copybuf(ID *id)
1811 {
1812         MTex **mtex = NULL;
1813
1814         if (mtexcopied == 0 || mtexcopybuf.tex == NULL)
1815                 return;
1816
1817         switch (GS(id->name)) {
1818                 case ID_MA:
1819                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1820                         break;
1821                 case ID_LA:
1822                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1823                         // la->mtex[(int)la->texact] // TODO
1824                         break;
1825                 case ID_WO:
1826                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1827                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1828                         break;
1829                 case ID_PA:
1830                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1831                         break;
1832                 case ID_LS:
1833                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1834                         break;
1835                 default:
1836                         BLI_assert(!"invalid id type");
1837                         return;
1838         }
1839
1840         if (mtex) {
1841                 if (*mtex == NULL) {
1842                         *mtex = MEM_mallocN(sizeof(MTex), "mtex copy");
1843                 }
1844                 else if ((*mtex)->tex) {
1845                         id_us_min(&(*mtex)->tex->id);
1846                 }
1847
1848                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
1849
1850                 id_us_plus((ID *)mtexcopybuf.tex);
1851         }
1852 }
1853
1854
1855 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1856 {
1857         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1858
1859         if (id == NULL) {
1860                 /* copying empty slot */
1861                 ED_render_clear_mtex_copybuf();
1862                 return OPERATOR_CANCELLED;
1863         }
1864
1865         copy_mtex_copybuf(id);
1866
1867         return OPERATOR_FINISHED;
1868 }
1869
1870 static bool copy_mtex_poll(bContext *C)
1871 {
1872         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1873
1874         return (id != NULL);
1875 }
1876
1877 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
1878 {
1879         /* identifiers */
1880         ot->name = "Copy Texture Slot Settings";
1881         ot->idname = "TEXTURE_OT_slot_copy";
1882         ot->description = "Copy the material texture settings and nodes";
1883
1884         /* api callbacks */
1885         ot->exec = copy_mtex_exec;
1886         ot->poll = copy_mtex_poll;
1887
1888         /* flags */
1889         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the mtex */
1890 }
1891
1892 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1893 {
1894         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1895
1896         if (id == NULL) {
1897                 Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1898                 Lamp *la = CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1899                 World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1900                 ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1901                 FreestyleLineStyle *linestyle = CTX_data_pointer_get_type(C, "line_style", &RNA_FreestyleLineStyle).data;
1902
1903                 if (ma)
1904                         id = &ma->id;
1905                 else if (la)
1906                         id = &la->id;
1907                 else if (wo)
1908                         id = &wo->id;
1909                 else if (psys)
1910                         id = &psys->part->id;
1911                 else if (linestyle)
1912                         id = &linestyle->id;
1913
1914                 if (id == NULL)
1915                         return OPERATOR_CANCELLED;
1916         }
1917
1918         paste_mtex_copybuf(id);
1919
1920         WM_event_add_notifier(C, NC_TEXTURE | ND_SHADING_LINKS, NULL);
1921
1922         return OPERATOR_FINISHED;
1923 }
1924
1925 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1926 {
1927         /* identifiers */
1928         ot->name = "Paste Texture Slot Settings";
1929         ot->idname = "TEXTURE_OT_slot_paste";
1930         ot->description = "Copy the texture settings and nodes";
1931
1932         /* api callbacks */
1933         ot->exec = paste_mtex_exec;
1934
1935         /* flags */
1936         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1937 }