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