Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / space_node / drawnode.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  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): David Millan Escriva, Juho Vepsäläinen, Bob Holcomb, Thomas Dinges
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_node/drawnode.c
29  *  \ingroup spnode
30  *  \brief lower level node drawing for nodes (boarders, headers etc), also node layout.
31  */
32
33 #include "BLI_blenlib.h"
34 #include "BLI_math.h"
35
36 #include "DNA_node_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_space_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_userdef_types.h"
41 #include "DNA_text_types.h"
42
43 #include "BKE_context.h"
44 #include "BKE_curve.h"
45 #include "BKE_image.h"
46 #include "BKE_main.h"
47 #include "BKE_node.h"
48 #include "BKE_tracking.h"
49
50 #include "BLF_api.h"
51 #include "BLT_translation.h"
52
53 #include "BIF_glutil.h"
54
55 #include "GPU_draw.h"
56 #include "GPU_immediate.h"
57 #include "GPU_matrix.h"
58
59 #include "RNA_access.h"
60 #include "RNA_define.h"
61
62 #include "ED_node.h"
63
64 #include "WM_api.h"
65 #include "WM_types.h"
66
67 #include "UI_resources.h"
68 #include "UI_view2d.h"
69
70 #include "IMB_colormanagement.h"
71 #include "IMB_imbuf_types.h"
72
73 #include "node_intern.h"  /* own include */
74 #include "NOD_composite.h"
75 #include "NOD_shader.h"
76 #include "NOD_texture.h"
77
78
79 /* ****************** SOCKET BUTTON DRAW FUNCTIONS ***************** */
80
81 static void node_socket_button_label(bContext *UNUSED(C), uiLayout *layout, PointerRNA *UNUSED(ptr), PointerRNA *UNUSED(node_ptr),
82                                      const char *text)
83 {
84         uiItemL(layout, text, 0);
85 }
86
87 /* ****************** BUTTON CALLBACKS FOR ALL TREES ***************** */
88
89 static void node_buts_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
90 {
91         bNode *node = ptr->data;
92         /* first output stores value */
93         bNodeSocket *output = node->outputs.first;
94         PointerRNA sockptr;
95         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr);
96         
97         uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE);
98 }
99
100 static void node_buts_rgb(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
101 {
102         bNode *node = ptr->data;
103         /* first output stores value */
104         bNodeSocket *output = node->outputs.first;
105         PointerRNA sockptr;
106         uiLayout *col;
107         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr);
108         
109         col = uiLayoutColumn(layout, false);
110         uiTemplateColorPicker(col, &sockptr, "default_value", 1, 0, 0, 0);
111         uiItemR(col, &sockptr, "default_value", UI_ITEM_R_SLIDER, "", ICON_NONE);
112 }
113
114 static void node_buts_mix_rgb(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
115 {       
116         uiLayout *row, *col;
117
118         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
119
120         col = uiLayoutColumn(layout, false);
121         row = uiLayoutRow(col, true);
122         uiItemR(row, ptr, "blend_type", 0, "", ICON_NONE);
123         if (ELEM(ntree->type, NTREE_COMPOSIT, NTREE_TEXTURE))
124                 uiItemR(row, ptr, "use_alpha", 0, "", ICON_IMAGE_RGB_ALPHA);
125
126         uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
127 }
128
129 static void node_buts_time(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
130 {
131         uiLayout *row;
132 #if 0
133         /* XXX no context access here .. */
134         bNode *node = ptr->data;
135         CurveMapping *cumap = node->storage;
136         
137         if (cumap) {
138                 cumap->flag |= CUMA_DRAW_CFRA;
139                 if (node->custom1 < node->custom2)
140                         cumap->sample[0] = (float)(CFRA - node->custom1) / (float)(node->custom2 - node->custom1);
141         }
142 #endif
143
144         uiTemplateCurveMapping(layout, ptr, "curve", 's', false, false, false);
145
146         row = uiLayoutRow(layout, true);
147         uiItemR(row, ptr, "frame_start", 0, IFACE_("Sta"), ICON_NONE);
148         uiItemR(row, ptr, "frame_end", 0, IFACE_("End"), ICON_NONE);
149 }
150
151 static void node_buts_colorramp(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
152 {
153         uiTemplateColorRamp(layout, ptr, "color_ramp", 0);
154 }
155
156 static void node_buts_curvevec(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
157 {
158         uiTemplateCurveMapping(layout, ptr, "mapping", 'v', false, false, false);
159 }
160
161 #define SAMPLE_FLT_ISNONE FLT_MAX
162 static float _sample_col[4] = {SAMPLE_FLT_ISNONE};  /* bad bad, 2.5 will do better?... no it won't... */
163 void ED_node_sample_set(const float col[4])
164 {
165         if (col) {
166                 copy_v4_v4(_sample_col, col);
167         }
168         else {
169                 copy_v4_fl(_sample_col, SAMPLE_FLT_ISNONE);
170         }
171 }
172
173 static void node_buts_curvecol(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
174 {
175         bNode *node = ptr->data;
176         CurveMapping *cumap = node->storage;
177
178         if (_sample_col[0] != SAMPLE_FLT_ISNONE) {
179                 cumap->flag |= CUMA_DRAW_SAMPLE;
180                 copy_v3_v3(cumap->sample, _sample_col);
181         }
182         else {
183                 cumap->flag &= ~CUMA_DRAW_SAMPLE;
184         }
185
186         uiTemplateCurveMapping(layout, ptr, "mapping", 'c', false, false, false);
187 }
188
189 static void node_buts_normal(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
190 {
191         bNode *node = ptr->data;
192         /* first output stores normal */
193         bNodeSocket *output = node->outputs.first;
194         PointerRNA sockptr;
195         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr);
196         
197         uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE);
198 }
199
200 #if 0 /* not used in 2.5x yet */
201 static void node_browse_tex_cb(bContext *C, void *ntree_v, void *node_v)
202 {
203         Main *bmain = CTX_data_main(C);
204         bNodeTree *ntree = ntree_v;
205         bNode *node = node_v;
206         Tex *tex;
207         
208         if (node->menunr < 1) return;
209         
210         if (node->id) {
211                 id_us_min(node->id);
212                 node->id = NULL;
213         }
214         tex = BLI_findlink(&bmain->tex, node->menunr - 1);
215
216         node->id = &tex->id;
217         id_us_plus(node->id);
218         BLI_strncpy(node->name, node->id->name + 2, sizeof(node->name));
219         
220         nodeSetActive(ntree, node);
221         
222         if (ntree->type == NTREE_TEXTURE)
223                 ntreeTexCheckCyclics(ntree);
224         
225         // allqueue(REDRAWBUTSSHADING, 0);
226         // allqueue(REDRAWNODE, 0);
227         NodeTagChanged(ntree, node); 
228         
229         node->menunr = 0;
230 }
231 #endif
232
233 static void node_buts_texture(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
234 {
235         bNode *node = ptr->data;
236
237         short multi = (
238             node->id &&
239             ((Tex *)node->id)->use_nodes &&
240             (node->type != CMP_NODE_TEXTURE) &&
241             (node->type != TEX_NODE_TEXTURE)
242             );
243         
244         uiItemR(layout, ptr, "texture", 0, "", ICON_NONE);
245         
246         if (multi) {
247                 /* Number Drawing not optimal here, better have a list*/
248                 uiItemR(layout, ptr, "node_output", 0, "", ICON_NONE);
249         }
250 }
251
252 static void node_buts_math(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
253
254         uiItemR(layout, ptr, "operation", 0, "", ICON_NONE);
255         uiItemR(layout, ptr, "use_clamp", 0, NULL, ICON_NONE);
256 }
257
258 static int node_resize_area_default(bNode *node, int x, int y)
259 {
260         if (node->flag & NODE_HIDDEN) {
261                 rctf totr = node->totr;
262                 /* right part of node */
263                 totr.xmin = node->totr.xmax - 20.0f;
264                 if (BLI_rctf_isect_pt(&totr, x, y))
265                         return NODE_RESIZE_RIGHT;
266                 else
267                         return 0;
268         }
269         else {
270                 const float size = 10.0f;
271                 rctf totr = node->totr;
272                 int dir = 0;
273                 
274                 if (x >= totr.xmax - size && x < totr.xmax && y >= totr.ymin && y < totr.ymax)
275                         dir |= NODE_RESIZE_RIGHT;
276                 if (x >= totr.xmin && x < totr.xmin + size && y >= totr.ymin && y < totr.ymax)
277                         dir |= NODE_RESIZE_LEFT;
278                 return dir;
279         }
280 }
281
282 /* ****************** BUTTON CALLBACKS FOR COMMON NODES ***************** */
283
284
285 static void node_draw_buttons_group(uiLayout *layout, bContext *C, PointerRNA *ptr)
286 {
287         uiTemplateIDBrowse(layout, C, ptr, "node_tree", NULL, NULL, NULL);
288 }
289
290 /* XXX Does a bounding box update by iterating over all children.
291  * Not ideal to do this in every draw call, but doing as transform callback doesn't work,
292  * since the child node totr rects are not updated properly at that point.
293  */
294 static void node_draw_frame_prepare(const bContext *UNUSED(C), bNodeTree *ntree, bNode *node)
295 {
296         const float margin = 1.5f * U.widget_unit;
297         NodeFrame *data = (NodeFrame *)node->storage;
298         bool bbinit;
299         bNode *tnode;
300         rctf rect, noderect;
301         float xmax, ymax;
302         
303         /* init rect from current frame size */
304         node_to_view(node, node->offsetx, node->offsety, &rect.xmin, &rect.ymax);
305         node_to_view(node, node->offsetx + node->width, node->offsety - node->height, &rect.xmax, &rect.ymin);
306         
307         /* frame can be resized manually only if shrinking is disabled or no children are attached */
308         data->flag |= NODE_FRAME_RESIZEABLE;
309         /* for shrinking bbox, initialize the rect from first child node */
310         bbinit = (data->flag & NODE_FRAME_SHRINK);
311         /* fit bounding box to all children */
312         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
313                 if (tnode->parent != node)
314                         continue;
315                 
316                 /* add margin to node rect */
317                 noderect = tnode->totr;
318                 noderect.xmin -= margin;
319                 noderect.xmax += margin;
320                 noderect.ymin -= margin;
321                 noderect.ymax += margin;
322                 
323                 /* first child initializes frame */
324                 if (bbinit) {
325                         bbinit = 0;
326                         rect = noderect;
327                         data->flag &= ~NODE_FRAME_RESIZEABLE;
328                 }
329                 else
330                         BLI_rctf_union(&rect, &noderect);
331         }
332         
333         /* now adjust the frame size from view-space bounding box */
334         node_from_view(node, rect.xmin, rect.ymax, &node->offsetx, &node->offsety);
335         node_from_view(node, rect.xmax, rect.ymin, &xmax, &ymax);
336         node->width = xmax - node->offsetx;
337         node->height = -ymax + node->offsety;
338         
339         node->totr = rect;
340 }
341
342 static void node_draw_frame_label(bNodeTree *ntree, bNode *node, const float aspect)
343 {
344         /* XXX font id is crap design */
345         const int fontid = UI_style_get()->widgetlabel.uifont_id;
346         NodeFrame *data = (NodeFrame *)node->storage;
347         rctf *rct = &node->totr;
348         int color_id = node_get_colorid(node);
349         char label[MAX_NAME];
350         /* XXX a bit hacky, should use separate align values for x and y */
351         float width, ascender;
352         float x, y;
353         const int font_size = data->label_size / aspect;
354         const float margin = (float)(NODE_DY / 4);
355         int label_height;
356         unsigned char color[3];
357
358         nodeLabel(ntree, node, label, sizeof(label));
359
360         BLF_enable(fontid, BLF_ASPECT);
361         BLF_aspect(fontid, aspect, aspect, 1.0f);
362         BLF_size(fontid, MIN2(24, font_size), U.dpi); /* clamp otherwise it can suck up a LOT of memory */
363         
364         /* title color */
365         UI_GetThemeColorBlendShade3ubv(TH_TEXT, color_id, 0.4f, 10, color);
366         BLF_color3ubv(fontid, color);
367
368         width = BLF_width(fontid, label, sizeof(label));
369         ascender = BLF_ascender(fontid);
370         label_height = ((margin / aspect) + (ascender * aspect));
371         
372         /* 'x' doesn't need aspect correction */
373         x = BLI_rctf_cent_x(rct) - (0.5f * width);
374         y = rct->ymax - label_height;
375
376         BLF_position(fontid, x, y, 0);
377         BLF_draw(fontid, label, BLF_DRAW_STR_DUMMY_MAX);
378
379         /* draw text body */
380         if (node->id) {
381                 Text *text = (Text *)node->id;
382                 TextLine *line;
383                 const int   line_height_max = BLF_height_max(fontid);
384                 const float line_spacing = (line_height_max * aspect);
385                 const float line_width = (BLI_rctf_size_x(rct) - margin) / aspect;
386                 int y_min;
387
388                 /* 'x' doesn't need aspect correction */
389                 x = rct->xmin + margin;
390                 y = rct->ymax - (label_height + line_spacing);
391                 /* early exit */
392                 y_min = y + ((margin * 2) - (y - rct->ymin));
393
394                 BLF_enable(fontid, BLF_CLIPPING | BLF_WORD_WRAP);
395                 BLF_clipping(
396                         fontid,
397                         rct->xmin,
398                         /* round to avoid clipping half-way through a line */
399                         y - (floorf(((y - rct->ymin) - (margin * 2)) / line_spacing) * line_spacing),
400                         rct->xmin + line_width,
401                         rct->ymax);
402
403                 BLF_wordwrap(fontid, line_width);
404
405                 for (line = text->lines.first; line; line = line->next) {
406                         struct ResultBLF info;
407                         if (line->line[0]) {
408                                 BLF_position(fontid, x, y, 0);
409                                 BLF_draw_ex(fontid, line->line, line->len, &info);
410                                 y -= line_spacing * info.lines;
411                         }
412                         else {
413                                 y -= line_spacing;
414                         }
415                         if (y < y_min) {
416                                 break;
417                         }
418                 }
419
420                 BLF_disable(fontid, BLF_CLIPPING | BLF_WORD_WRAP);
421         }
422
423         BLF_disable(fontid, BLF_ASPECT);
424 }
425
426 static void node_draw_frame(const bContext *C, ARegion *ar, SpaceNode *snode,
427                             bNodeTree *ntree, bNode *node, bNodeInstanceKey UNUSED(key))
428 {
429         rctf *rct = &node->totr;
430         int color_id = node_get_colorid(node);
431         float color[4];
432         float alpha;
433         
434         /* skip if out of view */
435         if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == false) {
436                 UI_block_end(C, node->block);
437                 node->block = NULL;
438                 return;
439         }
440
441         UI_GetThemeColor4fv(TH_NODE_FRAME, color);
442         alpha = color[3];
443         
444         /* shadow */
445         node_draw_shadow(snode, node, BASIS_RAD, alpha);
446         
447         /* body */
448         if (node->flag & NODE_CUSTOM_COLOR) {
449                 rgba_float_args_set(color, node->color[0], node->color[1], node->color[2], alpha);
450         }
451         else
452                 UI_GetThemeColor4fv(TH_NODE_FRAME, color);
453
454         UI_draw_roundbox_corner_set(UI_CNR_ALL);
455         UI_draw_roundbox_aa(true, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);
456
457         /* outline active and selected emphasis */
458         if (node->flag & SELECT) {
459                 if (node->flag & NODE_ACTIVE)
460                         UI_GetThemeColorShadeAlpha4fv(TH_ACTIVE, 0, -40, color);
461                 else
462                         UI_GetThemeColorShadeAlpha4fv(TH_SELECT, 0, -40, color);
463
464                 UI_draw_roundbox_aa(false, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);
465         }
466
467         /* label */
468         node_draw_frame_label(ntree, node, snode->aspect);
469         
470         UI_ThemeClearColor(color_id);
471                 
472         UI_block_end(C, node->block);
473         UI_block_draw(C, node->block);
474         node->block = NULL;
475 }
476
477 static int node_resize_area_frame(bNode *node, int x, int y)
478 {
479         const float size = 10.0f;
480         NodeFrame *data = (NodeFrame *)node->storage;
481         rctf totr = node->totr;
482         int dir = 0;
483         
484         /* shrinking frame size is determined by child nodes */
485         if (!(data->flag & NODE_FRAME_RESIZEABLE))
486                 return 0;
487         
488         if (x >= totr.xmax - size && x < totr.xmax && y >= totr.ymin && y < totr.ymax)
489                 dir |= NODE_RESIZE_RIGHT;
490         if (x >= totr.xmin && x < totr.xmin + size && y >= totr.ymin && y < totr.ymax)
491                 dir |= NODE_RESIZE_LEFT;
492         if (x >= totr.xmin && x < totr.xmax && y >= totr.ymax - size && y < totr.ymax)
493                 dir |= NODE_RESIZE_TOP;
494         if (x >= totr.xmin && x < totr.xmax && y >= totr.ymin && y < totr.ymin + size)
495                 dir |= NODE_RESIZE_BOTTOM;
496         
497         return dir;
498 }
499
500 static void node_buts_frame_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
501 {
502         uiItemR(layout, ptr, "label_size", 0, IFACE_("Label Size"), ICON_NONE);
503         uiItemR(layout, ptr, "shrink", 0, IFACE_("Shrink"), ICON_NONE);
504         uiItemR(layout, ptr, "text", 0, NULL, ICON_NONE);
505 }
506
507
508 #define NODE_REROUTE_SIZE   8.0f
509
510 static void node_draw_reroute_prepare(const bContext *UNUSED(C), bNodeTree *UNUSED(ntree), bNode *node)
511 {
512         bNodeSocket *nsock;
513         float locx, locy;
514         float size = NODE_REROUTE_SIZE;
515         
516         /* get "global" coords */
517         node_to_view(node, 0.0f, 0.0f, &locx, &locy);
518         
519         /* reroute node has exactly one input and one output, both in the same place */
520         nsock = node->outputs.first;
521         nsock->locx = locx;
522         nsock->locy = locy;
523
524         nsock = node->inputs.first;
525         nsock->locx = locx;
526         nsock->locy = locy;
527
528         node->width = size * 2;
529         node->totr.xmin = locx - size;
530         node->totr.xmax = locx + size;
531         node->totr.ymax = locy + size;
532         node->totr.ymin = locy - size;
533 }
534
535 static void node_draw_reroute(const bContext *C, ARegion *ar, SpaceNode *UNUSED(snode),
536                               bNodeTree *ntree, bNode *node, bNodeInstanceKey UNUSED(key))
537 {
538         char showname[128]; /* 128 used below */
539         rctf *rct = &node->totr;
540
541         /* skip if out of view */
542         if (node->totr.xmax < ar->v2d.cur.xmin || node->totr.xmin > ar->v2d.cur.xmax ||
543             node->totr.ymax < ar->v2d.cur.ymin || node->totr.ymin > ar->v2d.cur.ymax)
544         {
545                 UI_block_end(C, node->block);
546                 node->block = NULL;
547                 return;
548         }
549
550         /* XXX only kept for debugging
551          * selection state is indicated by socket outline below!
552          */
553 #if 0
554         float size = NODE_REROUTE_SIZE;
555
556         /* body */
557         float debug_color[4];
558         UI_draw_roundbox_corner_set(UI_CNR_ALL);
559         UI_GetThemeColor4fv(TH_NODE, debug_color);
560         UI_draw_roundbox_aa(true, rct->xmin, rct->ymin, rct->xmax, rct->ymax, size, debug_color);
561
562         /* outline active and selected emphasis */
563         if (node->flag & SELECT) {
564                 glEnable(GL_BLEND);
565                 glEnable(GL_LINE_SMOOTH);
566                 /* using different shades of TH_TEXT_HI for the empasis, like triangle */
567                 if (node->flag & NODE_ACTIVE) {
568                         UI_GetThemeColorShadeAlpha4fv(TH_TEXT_HI, 0, -40, debug_color);
569                 }
570                 else {
571                         UI_GetThemeColorShadeAlpha4fv(TH_TEXT_HI, -20, -120, debug_color);
572                 }
573                 UI_draw_roundbox_4fv(false, rct->xmin, rct->ymin, rct->xmax, rct->ymax, size, debug_color);
574
575                 glDisable(GL_LINE_SMOOTH);
576                 glDisable(GL_BLEND);
577         }
578 #endif
579
580         if (node->label[0] != '\0') {
581                 /* draw title (node label) */
582                 BLI_strncpy(showname, node->label, sizeof(showname));
583                 uiDefBut(node->block, UI_BTYPE_LABEL, 0, showname,
584                          (int)(rct->xmin - NODE_DYS), (int)(rct->ymax),
585                          (short)512, (short)NODE_DY,
586                          NULL, 0, 0, 0, 0, NULL);
587         }
588
589         /* only draw input socket. as they all are placed on the same position.
590          * highlight also if node itself is selected, since we don't display the node body separately!
591          */
592         node_draw_sockets(&ar->v2d, C, ntree, node, false, node->flag & SELECT);
593
594         UI_block_end(C, node->block);
595         UI_block_draw(C, node->block);
596         node->block = NULL;
597 }
598
599 /* Special tweak area for reroute node.
600  * Since this node is quite small, we use a larger tweak area for grabbing than for selection.
601  */
602 static int node_tweak_area_reroute(bNode *node, int x, int y)
603 {
604         /* square of tweak radius */
605         const float tweak_radius_sq = SQUARE(24);
606         
607         bNodeSocket *sock = node->inputs.first;
608         float dx = sock->locx - x;
609         float dy = sock->locy - y;
610         return (dx * dx + dy * dy <= tweak_radius_sq);
611 }
612
613 static void node_common_set_butfunc(bNodeType *ntype)
614 {
615         switch (ntype->type) {
616                 case NODE_GROUP:
617                         ntype->draw_buttons = node_draw_buttons_group;
618                         break;
619                 case NODE_FRAME:
620                         ntype->draw_nodetype = node_draw_frame;
621                         ntype->draw_nodetype_prepare = node_draw_frame_prepare;
622                         ntype->draw_buttons_ex = node_buts_frame_ex;
623                         ntype->resize_area_func = node_resize_area_frame;
624                         break;
625                 case NODE_REROUTE:
626                         ntype->draw_nodetype = node_draw_reroute;
627                         ntype->draw_nodetype_prepare = node_draw_reroute_prepare;
628                         ntype->tweak_area_func = node_tweak_area_reroute;
629                         break;
630         }
631 }
632
633 /* ****************** BUTTON CALLBACKS FOR SHADER NODES ***************** */
634
635 static void node_buts_image_user(uiLayout *layout, bContext *C, PointerRNA *ptr,
636                                  PointerRNA *imaptr, PointerRNA *iuserptr)
637 {
638         uiLayout *col;
639         int source;
640
641         if (!imaptr->data)
642                 return;
643
644         col = uiLayoutColumn(layout, false);
645         
646         uiItemR(col, imaptr, "source", 0, "", ICON_NONE);
647         
648         source = RNA_enum_get(imaptr, "source");
649
650         if (source == IMA_SRC_SEQUENCE) {
651                 /* don't use iuser->framenr directly because it may not be updated if auto-refresh is off */
652                 Scene *scene = CTX_data_scene(C);
653                 ImageUser *iuser = iuserptr->data;
654                 /* Image *ima = imaptr->data; */  /* UNUSED */
655
656                 char numstr[32];
657                 const int framenr = BKE_image_user_frame_get(iuser, CFRA, 0, NULL);
658                 BLI_snprintf(numstr, sizeof(numstr), IFACE_("Frame: %d"), framenr);
659                 uiItemL(layout, numstr, ICON_NONE);
660         }
661
662         if (ELEM(source, IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) {
663                 col = uiLayoutColumn(layout, true);
664                 uiItemR(col, ptr, "frame_duration", 0, NULL, ICON_NONE);
665                 uiItemR(col, ptr, "frame_start", 0, NULL, ICON_NONE);
666                 uiItemR(col, ptr, "frame_offset", 0, NULL, ICON_NONE);
667                 uiItemR(col, ptr, "use_cyclic", 0, NULL, ICON_NONE);
668                 uiItemR(col, ptr, "use_auto_refresh", 0, NULL, ICON_NONE);
669         }
670
671         if (RNA_enum_get(imaptr, "type") == IMA_TYPE_MULTILAYER &&
672             RNA_boolean_get(ptr, "has_layers"))
673         {
674                 col = uiLayoutColumn(layout, false);
675                 uiItemR(col, ptr, "layer", 0, NULL, ICON_NONE);
676         }
677 }
678
679 static void node_shader_buts_material(uiLayout *layout, bContext *C, PointerRNA *ptr)
680 {
681         bNode *node = ptr->data;
682         uiLayout *col;
683         
684         uiTemplateID(layout, C, ptr, "material", "MATERIAL_OT_new", NULL, NULL);
685         
686         if (!node->id) return;
687         
688         col = uiLayoutColumn(layout, false);
689         uiItemR(col, ptr, "use_diffuse", 0, NULL, ICON_NONE);
690         uiItemR(col, ptr, "use_specular", 0, NULL, ICON_NONE);
691         uiItemR(col, ptr, "invert_normal", 0, NULL, ICON_NONE);
692 }
693
694 static void node_shader_buts_mapping(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
695 {
696         uiLayout *row, *col, *sub;
697
698         uiItemR(layout, ptr, "vector_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
699
700         row = uiLayoutRow(layout, false);
701
702         col = uiLayoutColumn(row, true);
703         uiItemL(col, IFACE_("Location:"), ICON_NONE);
704         uiItemR(col, ptr, "translation", 0, "", ICON_NONE);
705
706         col = uiLayoutColumn(row, true);
707         uiItemL(col, IFACE_("Rotation:"), ICON_NONE);
708         uiItemR(col, ptr, "rotation", 0, "", ICON_NONE);
709
710         col = uiLayoutColumn(row, true);
711         uiItemL(col, IFACE_("Scale:"), ICON_NONE);
712         uiItemR(col, ptr, "scale", 0, "", ICON_NONE);
713
714         row = uiLayoutRow(layout, false);
715
716         col = uiLayoutColumn(row, true);
717         uiItemR(col, ptr, "use_min", 0, IFACE_("Min"), ICON_NONE);
718         sub = uiLayoutColumn(col, true);
719         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_min"));
720         uiItemR(sub, ptr, "min", 0, "", ICON_NONE);
721
722         col = uiLayoutColumn(row, true);
723         uiItemR(col, ptr, "use_max", 0, IFACE_("Max"), ICON_NONE);
724         sub = uiLayoutColumn(col, true);
725         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_max"));
726         uiItemR(sub, ptr, "max", 0, "", ICON_NONE);
727 }
728
729 static void node_shader_buts_vect_math(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
730
731         uiItemR(layout, ptr, "operation", 0, "", ICON_NONE);
732 }
733
734 static void node_shader_buts_vect_transform(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
735
736         uiItemR(layout, ptr, "vector_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
737         uiItemR(layout, ptr, "convert_from", 0, "", ICON_NONE);
738         uiItemR(layout, ptr, "convert_to", 0, "", ICON_NONE);
739 }
740
741 static void node_shader_buts_geometry(uiLayout *layout, bContext *C, PointerRNA *ptr)
742 {
743         PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
744         uiLayout *col;
745
746         col = uiLayoutColumn(layout, false);
747
748         if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
749                 PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
750
751                 uiItemPointerR(col, ptr, "uv_layer", &dataptr, "uv_layers", "", ICON_NONE);
752                 uiItemPointerR(col, ptr, "color_layer", &dataptr, "vertex_colors", "", ICON_NONE);
753         }
754         else {
755                 uiItemR(col, ptr, "uv_layer", 0, IFACE_("UV"), ICON_NONE);
756                 uiItemR(col, ptr, "color_layer", 0, IFACE_("VCol"), ICON_NONE);
757         }
758 }
759
760 static void node_shader_buts_lamp(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
761 {
762         uiItemR(layout, ptr, "lamp_object", 0, IFACE_("Lamp Object"), ICON_NONE);
763 }
764
765 static void node_shader_buts_attribute(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
766 {
767         uiItemR(layout, ptr, "attribute_name", 0, IFACE_("Name"), ICON_NONE);
768 }
769
770 static void node_shader_buts_wireframe(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
771 {
772         uiItemR(layout, ptr, "use_pixel_size", 0, NULL, 0);
773 }
774
775 static void node_shader_buts_tex_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
776 {
777         PointerRNA imaptr = RNA_pointer_get(ptr, "image");
778         PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
779
780         uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
781         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
782         uiItemR(layout, ptr, "color_space", 0, "", ICON_NONE);
783         uiItemR(layout, ptr, "interpolation", 0, "", ICON_NONE);
784         uiItemR(layout, ptr, "projection", 0, "", ICON_NONE);
785
786         if (RNA_enum_get(ptr, "projection") == SHD_PROJ_BOX) {
787                 uiItemR(layout, ptr, "projection_blend", 0, "Blend", ICON_NONE);
788         }
789
790         uiItemR(layout, ptr, "extension", 0, "", ICON_NONE);
791
792         /* note: image user properties used directly here, unlike compositor image node,
793          * which redefines them in the node struct RNA to get proper updates.
794          */
795         node_buts_image_user(layout, C, &iuserptr, &imaptr, &iuserptr);
796 }
797
798 static void node_shader_buts_tex_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
799 {
800         PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
801         uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 0);
802 }
803
804 static void node_shader_buts_tex_environment(uiLayout *layout, bContext *C, PointerRNA *ptr)
805 {
806         PointerRNA imaptr = RNA_pointer_get(ptr, "image");
807         PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
808
809         uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
810         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
811
812         node_buts_image_user(layout, C, &iuserptr, &imaptr, &iuserptr);
813
814         uiItemR(layout, ptr, "color_space", 0, "", ICON_NONE);
815         uiItemR(layout, ptr, "interpolation", 0, "", ICON_NONE);
816         uiItemR(layout, ptr, "projection", 0, "", ICON_NONE);
817 }
818
819 static void node_shader_buts_tex_environment_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
820 {
821         PointerRNA imaptr = RNA_pointer_get(ptr, "image");
822         PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
823         Image *ima = imaptr.data;
824
825         uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
826         uiTemplateID(layout, C, ptr, "image", ima ? NULL : "IMAGE_OT_new", "IMAGE_OT_open", NULL);
827
828         if (!ima)
829                 return;
830
831         uiItemR(layout, &imaptr, "source", 0, IFACE_("Source"), ICON_NONE);
832
833         if (!(ELEM(ima->source, IMA_SRC_GENERATED, IMA_SRC_VIEWER))) {
834                 uiLayout *row = uiLayoutRow(layout, true);
835                 const bool is_packed = BKE_image_has_packedfile(ima);
836
837                 if (is_packed)
838                         uiItemO(row, "", ICON_PACKAGE, "image.unpack");
839                 else
840                         uiItemO(row, "", ICON_UGLYPACKAGE, "image.pack");
841
842                 row = uiLayoutRow(row, true);
843                 uiLayoutSetEnabled(row, !is_packed);
844                 uiItemR(row, &imaptr, "filepath", 0, "", ICON_NONE);
845                 uiItemO(row, "", ICON_FILE_REFRESH, "image.reload");
846         }
847
848         /* multilayer? */
849         if (ima->type == IMA_TYPE_MULTILAYER && ima->rr) {
850                 uiTemplateImageLayers(layout, C, ima, iuserptr.data);
851         }
852         else if (ima->source != IMA_SRC_GENERATED) {
853                 uiTemplateImageInfo(layout, C, ima, iuserptr.data);
854         }
855
856         uiItemR(layout, ptr, "color_space", 0, IFACE_("Color Space"), ICON_NONE);
857         uiItemR(layout, ptr, "interpolation", 0, IFACE_("Interpolation"), ICON_NONE);
858         uiItemR(layout, ptr, "projection", 0, IFACE_("Projection"), ICON_NONE);
859 }
860
861 static void node_shader_buts_tex_sky(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
862 {       
863         uiItemR(layout, ptr, "sky_type", 0, "", ICON_NONE);
864         uiItemR(layout, ptr, "sun_direction", 0, "", ICON_NONE);
865         uiItemR(layout, ptr, "turbidity", 0, NULL, ICON_NONE);
866
867         if (RNA_enum_get(ptr, "sky_type") == SHD_SKY_NEW)
868                 uiItemR(layout, ptr, "ground_albedo", 0, NULL, ICON_NONE);
869 }
870
871 static void node_shader_buts_tex_gradient(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
872 {
873         uiItemR(layout, ptr, "gradient_type", 0, "", ICON_NONE);
874 }
875
876 static void node_shader_buts_tex_magic(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
877 {
878         uiItemR(layout, ptr, "turbulence_depth", 0, NULL, ICON_NONE);
879 }
880
881 static void node_shader_buts_tex_brick(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
882 {
883         uiLayout *col;
884         
885         col = uiLayoutColumn(layout, true);
886         uiItemR(col, ptr, "offset", UI_ITEM_R_SLIDER, IFACE_("Offset"), ICON_NONE);
887         uiItemR(col, ptr, "offset_frequency", 0, IFACE_("Frequency"), ICON_NONE);
888         
889         col = uiLayoutColumn(layout, true);
890         uiItemR(col, ptr, "squash", 0, IFACE_("Squash"), ICON_NONE);
891         uiItemR(col, ptr, "squash_frequency", 0, IFACE_("Frequency"), ICON_NONE);
892 }
893
894 static void node_shader_buts_tex_wave(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
895 {
896         uiItemR(layout, ptr, "wave_type", 0, "", ICON_NONE);
897         uiItemR(layout, ptr, "wave_profile", 0, "", ICON_NONE);
898 }
899
900 static void node_shader_buts_tex_musgrave(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
901 {
902         uiItemR(layout, ptr, "musgrave_type", 0, "", ICON_NONE);
903 }
904
905 static void node_shader_buts_tex_voronoi(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
906 {
907         uiItemR(layout, ptr, "coloring", 0, "", ICON_NONE);
908 }
909
910 static void node_shader_buts_tex_pointdensity(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
911 {
912         bNode *node = ptr->data;
913         NodeShaderTexPointDensity *shader_point_density = node->storage;
914         Object *ob = (Object *)node->id;
915         PointerRNA ob_ptr, obdata_ptr;
916
917         RNA_id_pointer_create((ID *)ob, &ob_ptr);
918         RNA_id_pointer_create(ob ? (ID *)ob->data : NULL, &obdata_ptr);
919
920         uiItemR(layout, ptr, "point_source", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
921         uiItemR(layout, ptr, "object", 0, NULL, ICON_NONE);
922
923         if (node->id && shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
924                 PointerRNA dataptr;
925                 RNA_id_pointer_create((ID *)node->id, &dataptr);
926                 uiItemPointerR(layout, ptr, "particle_system", &dataptr, "particle_systems", NULL, ICON_NONE);
927         }
928
929         uiItemR(layout, ptr, "space", 0, NULL, ICON_NONE);
930         uiItemR(layout, ptr, "radius", 0, NULL, ICON_NONE);
931         uiItemR(layout, ptr, "interpolation", 0, NULL, ICON_NONE);
932         uiItemR(layout, ptr, "resolution", 0, NULL, ICON_NONE);
933         if (shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
934                 uiItemR(layout, ptr, "particle_color_source", 0, NULL, ICON_NONE);
935         }
936         else {
937                 uiItemR(layout, ptr, "vertex_color_source", 0, NULL, ICON_NONE);
938                 if (shader_point_density->ob_color_source == SHD_POINTDENSITY_COLOR_VERTWEIGHT) {
939                         if (ob_ptr.data)
940                                 uiItemPointerR(layout, ptr, "vertex_attribute_name", &ob_ptr, "vertex_groups", "", ICON_NONE);
941                 }
942                 if (shader_point_density->ob_color_source == SHD_POINTDENSITY_COLOR_VERTCOL) {
943                         if (obdata_ptr.data)
944                                 uiItemPointerR(layout, ptr, "vertex_attribute_name", &obdata_ptr, "vertex_colors", "", ICON_NONE);
945                 }
946         }
947 }
948
949 static void node_shader_buts_tex_coord(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
950 {
951         uiItemR(layout, ptr, "object", 0, NULL, 0);
952         uiItemR(layout, ptr, "from_dupli", 0, NULL, 0);
953 }
954
955 static void node_shader_buts_bump(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
956 {
957         uiItemR(layout, ptr, "invert", 0, NULL, 0);
958 }
959
960 static void node_shader_buts_uvmap(uiLayout *layout, bContext *C, PointerRNA *ptr)
961 {
962         uiItemR(layout, ptr, "from_dupli", 0, NULL, 0);
963
964         if (!RNA_boolean_get(ptr, "from_dupli")) {
965                 PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
966
967                 if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
968                         PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
969                         uiItemPointerR(layout, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
970                 }
971         }
972 }
973
974 static void node_shader_buts_uvalongstroke(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
975 {
976         uiItemR(layout, ptr, "use_tips", 0, NULL, 0);
977 }
978
979 static void node_shader_buts_normal_map(uiLayout *layout, bContext *C, PointerRNA *ptr)
980 {
981         uiItemR(layout, ptr, "space", 0, "", 0);
982
983         if (RNA_enum_get(ptr, "space") == SHD_NORMAL_MAP_TANGENT) {
984                 PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
985
986                 if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
987                         PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
988                         uiItemPointerR(layout, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
989                 }
990                 else
991                         uiItemR(layout, ptr, "uv_map", 0, "", 0);
992         }
993 }
994
995 static void node_shader_buts_tangent(uiLayout *layout, bContext *C, PointerRNA *ptr)
996 {
997         uiLayout *split, *row;
998
999         split = uiLayoutSplit(layout, 0.0f, false);
1000
1001         uiItemR(split, ptr, "direction_type", 0, "", 0);
1002
1003         row = uiLayoutRow(split, false);
1004
1005         if (RNA_enum_get(ptr, "direction_type") == SHD_TANGENT_UVMAP) {
1006                 PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
1007
1008                 if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
1009                         PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
1010                         uiItemPointerR(row, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
1011                 }
1012                 else
1013                         uiItemR(row, ptr, "uv_map", 0, "", 0);
1014         }
1015         else
1016                 uiItemR(row, ptr, "axis", UI_ITEM_R_EXPAND, NULL, 0);
1017 }
1018
1019 static void node_shader_buts_glossy(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1020 {
1021         uiItemR(layout, ptr, "distribution", 0, "", ICON_NONE);
1022 }
1023
1024 static void node_shader_buts_anisotropic(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1025 {
1026         uiItemR(layout, ptr, "distribution", 0, "", ICON_NONE);
1027 }
1028
1029 static void node_shader_buts_subsurface(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1030 {
1031         uiItemR(layout, ptr, "falloff", 0, "", ICON_NONE);
1032 }
1033
1034
1035 static void node_shader_buts_toon(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1036 {
1037         uiItemR(layout, ptr, "component", 0, "", ICON_NONE);
1038 }
1039
1040 static void node_shader_buts_hair(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1041 {
1042         uiItemR(layout, ptr, "component", 0, "", ICON_NONE);
1043 }
1044
1045 static void node_shader_buts_script(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1046 {
1047         uiLayout *row;
1048
1049         row = uiLayoutRow(layout, false);
1050         uiItemR(row, ptr, "mode", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1051
1052         row = uiLayoutRow(layout, true);
1053
1054         if (RNA_enum_get(ptr, "mode") == NODE_SCRIPT_INTERNAL)
1055                 uiItemR(row, ptr, "script", 0, "", ICON_NONE);
1056         else
1057                 uiItemR(row, ptr, "filepath", 0, "", ICON_NONE);
1058
1059         uiItemO(row, "", ICON_FILE_REFRESH, "node.shader_script_update");
1060 }
1061
1062 static void node_shader_buts_script_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1063 {
1064         uiItemS(layout);
1065
1066         node_shader_buts_script(layout, C, ptr);
1067
1068 #if 0  /* not implemented yet */
1069         if (RNA_enum_get(ptr, "mode") == NODE_SCRIPT_EXTERNAL)
1070                 uiItemR(layout, ptr, "use_auto_update", 0, NULL, ICON_NONE);
1071 #endif
1072 }
1073
1074 static void node_buts_output_linestyle(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1075 {
1076         uiLayout *row, *col;
1077
1078         col = uiLayoutColumn(layout, false);
1079         row = uiLayoutRow(col, true);
1080         uiItemR(row, ptr, "blend_type", 0, "", ICON_NONE);
1081         uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
1082 }
1083
1084 static void node_shader_buts_bevel(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1085 {
1086         uiItemR(layout, ptr, "samples", 0, NULL, ICON_NONE);
1087 }
1088
1089 /* only once called */
1090 static void node_shader_set_butfunc(bNodeType *ntype)
1091 {
1092         switch (ntype->type) {
1093                 case SH_NODE_MATERIAL:
1094                 case SH_NODE_MATERIAL_EXT:
1095                         ntype->draw_buttons = node_shader_buts_material;
1096                         break;
1097                 case SH_NODE_TEXTURE:
1098                         ntype->draw_buttons = node_buts_texture;
1099                         break;
1100                 case SH_NODE_NORMAL:
1101                         ntype->draw_buttons = node_buts_normal;
1102                         break;
1103                 case SH_NODE_CURVE_VEC:
1104                         ntype->draw_buttons = node_buts_curvevec;
1105                         break;
1106                 case SH_NODE_CURVE_RGB:
1107                         ntype->draw_buttons = node_buts_curvecol;
1108                         break;
1109                 case SH_NODE_MAPPING:
1110                         ntype->draw_buttons = node_shader_buts_mapping;
1111                         break;
1112                 case SH_NODE_VALUE:
1113                         ntype->draw_buttons = node_buts_value;
1114                         break;
1115                 case SH_NODE_RGB:
1116                         ntype->draw_buttons = node_buts_rgb;
1117                         break;
1118                 case SH_NODE_MIX_RGB:
1119                         ntype->draw_buttons = node_buts_mix_rgb;
1120                         break;
1121                 case SH_NODE_VALTORGB:
1122                         ntype->draw_buttons = node_buts_colorramp;
1123                         break;
1124                 case SH_NODE_MATH: 
1125                         ntype->draw_buttons = node_buts_math;
1126                         break; 
1127                 case SH_NODE_VECT_MATH: 
1128                         ntype->draw_buttons = node_shader_buts_vect_math;
1129                         break; 
1130                 case SH_NODE_VECT_TRANSFORM: 
1131                         ntype->draw_buttons = node_shader_buts_vect_transform;
1132                         break; 
1133                 case SH_NODE_GEOMETRY:
1134                         ntype->draw_buttons = node_shader_buts_geometry;
1135                         break;
1136                 case SH_NODE_LAMP:
1137                         ntype->draw_buttons = node_shader_buts_lamp;
1138                         break;
1139                 case SH_NODE_ATTRIBUTE:
1140                         ntype->draw_buttons = node_shader_buts_attribute;
1141                         break;
1142                 case SH_NODE_WIREFRAME:
1143                         ntype->draw_buttons = node_shader_buts_wireframe;
1144                         break;
1145                 case SH_NODE_TEX_SKY:
1146                         ntype->draw_buttons = node_shader_buts_tex_sky;
1147                         break;
1148                 case SH_NODE_TEX_IMAGE:
1149                         ntype->draw_buttons = node_shader_buts_tex_image;
1150                         ntype->draw_buttons_ex = node_shader_buts_tex_image_ex;
1151                         break;
1152                 case SH_NODE_TEX_ENVIRONMENT:
1153                         ntype->draw_buttons = node_shader_buts_tex_environment;
1154                         ntype->draw_buttons_ex = node_shader_buts_tex_environment_ex;
1155                         break;
1156                 case SH_NODE_TEX_GRADIENT:
1157                         ntype->draw_buttons = node_shader_buts_tex_gradient;
1158                         break;
1159                 case SH_NODE_TEX_MAGIC:
1160                         ntype->draw_buttons = node_shader_buts_tex_magic;
1161                         break;
1162                 case SH_NODE_TEX_BRICK:
1163                         ntype->draw_buttons = node_shader_buts_tex_brick;
1164                         break;
1165                 case SH_NODE_TEX_WAVE:
1166                         ntype->draw_buttons = node_shader_buts_tex_wave;
1167                         break;
1168                 case SH_NODE_TEX_MUSGRAVE:
1169                         ntype->draw_buttons = node_shader_buts_tex_musgrave;
1170                         break;
1171                 case SH_NODE_TEX_VORONOI:
1172                         ntype->draw_buttons = node_shader_buts_tex_voronoi;
1173                         break;
1174                 case SH_NODE_TEX_POINTDENSITY:
1175                         ntype->draw_buttons = node_shader_buts_tex_pointdensity;
1176                         break;
1177                 case SH_NODE_TEX_COORD:
1178                         ntype->draw_buttons = node_shader_buts_tex_coord;
1179                         break;
1180                 case SH_NODE_BUMP:
1181                         ntype->draw_buttons = node_shader_buts_bump;
1182                         break;
1183                 case SH_NODE_NORMAL_MAP:
1184                         ntype->draw_buttons = node_shader_buts_normal_map;
1185                         break;
1186                 case SH_NODE_TANGENT:
1187                         ntype->draw_buttons = node_shader_buts_tangent;
1188                         break;
1189                 case SH_NODE_BSDF_GLOSSY:
1190                 case SH_NODE_BSDF_GLASS:
1191                 case SH_NODE_BSDF_REFRACTION:
1192                 case SH_NODE_BSDF_PRINCIPLED:
1193                         ntype->draw_buttons = node_shader_buts_glossy;
1194                         break;
1195                 case SH_NODE_BSDF_ANISOTROPIC:
1196                         ntype->draw_buttons = node_shader_buts_anisotropic;
1197                         break;
1198                 case SH_NODE_SUBSURFACE_SCATTERING:
1199                         ntype->draw_buttons = node_shader_buts_subsurface;
1200                         break;
1201                 case SH_NODE_BSDF_TOON:
1202                         ntype->draw_buttons = node_shader_buts_toon;
1203                         break;
1204                 case SH_NODE_BSDF_HAIR:
1205                         ntype->draw_buttons = node_shader_buts_hair;
1206                         break;
1207                 case SH_NODE_SCRIPT:
1208                         ntype->draw_buttons = node_shader_buts_script;
1209                         ntype->draw_buttons_ex = node_shader_buts_script_ex;
1210                         break;
1211                 case SH_NODE_UVMAP:
1212                         ntype->draw_buttons = node_shader_buts_uvmap;
1213                         break;
1214                 case SH_NODE_UVALONGSTROKE:
1215                         ntype->draw_buttons = node_shader_buts_uvalongstroke;
1216                         break;
1217                 case SH_NODE_OUTPUT_LINESTYLE:
1218                         ntype->draw_buttons = node_buts_output_linestyle;
1219                         break;
1220                 case SH_NODE_BEVEL:
1221                         ntype->draw_buttons = node_shader_buts_bevel;
1222                         break;
1223         }
1224 }
1225
1226 /* ****************** BUTTON CALLBACKS FOR COMPOSITE NODES ***************** */
1227
1228 static void node_buts_image_views(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr,
1229                                  PointerRNA *imaptr)
1230 {
1231         uiLayout *col;
1232
1233         if (!imaptr->data)
1234                 return;
1235
1236         col = uiLayoutColumn(layout, false);
1237
1238         if (RNA_boolean_get(ptr, "has_views")) {
1239                 if (RNA_enum_get(ptr, "view") == 0)
1240                         uiItemR(col, ptr, "view", 0, NULL, ICON_CAMERA_STEREO);
1241                 else
1242                         uiItemR(col, ptr, "view", 0, NULL, ICON_SCENE);
1243         }
1244 }
1245
1246 static void node_composit_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
1247 {
1248         bNode *node = ptr->data;
1249         PointerRNA imaptr, iuserptr;
1250         
1251         RNA_pointer_create((ID *)ptr->id.data, &RNA_ImageUser, node->storage, &iuserptr);
1252         uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
1253         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
1254         if (!node->id) return;
1255         
1256         imaptr = RNA_pointer_get(ptr, "image");
1257
1258         node_buts_image_user(layout, C, ptr, &imaptr, &iuserptr);
1259
1260         node_buts_image_views(layout, C, ptr, &imaptr);
1261 }
1262
1263 static void node_composit_buts_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1264 {
1265         bNode *node = ptr->data;
1266         PointerRNA iuserptr;
1267
1268         RNA_pointer_create((ID *)ptr->id.data, &RNA_ImageUser, node->storage, &iuserptr);
1269         uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
1270         uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 1);
1271 }
1272
1273 static void node_composit_buts_renderlayers(uiLayout *layout, bContext *C, PointerRNA *ptr)
1274 {
1275         bNode *node = ptr->data;
1276         uiLayout *col, *row;
1277         PointerRNA op_ptr;
1278         PointerRNA scn_ptr;
1279         PropertyRNA *prop;
1280         const char *layer_name;
1281         char scene_name[MAX_ID_NAME - 2];
1282
1283         uiTemplateID(layout, C, ptr, "scene", NULL, NULL, NULL);
1284         
1285         if (!node->id) return;
1286
1287         col = uiLayoutColumn(layout, false);
1288         row = uiLayoutRow(col, true);
1289         uiItemR(row, ptr, "layer", 0, "", ICON_NONE);
1290         
1291         prop = RNA_struct_find_property(ptr, "layer");
1292         if (!(RNA_property_enum_identifier(C, ptr, prop, RNA_property_enum_get(ptr, prop), &layer_name)))
1293                 return;
1294         
1295         scn_ptr = RNA_pointer_get(ptr, "scene");
1296         RNA_string_get(&scn_ptr, "name", scene_name);
1297
1298         uiItemFullO(row, "RENDER_OT_render", "", ICON_RENDER_STILL, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1299         RNA_string_set(&op_ptr, "layer", layer_name);
1300         RNA_string_set(&op_ptr, "scene", scene_name);
1301 }
1302
1303
1304 static void node_composit_buts_blur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1305 {
1306         uiLayout *col, *row;
1307         int reference;
1308         int filter;
1309         
1310         col = uiLayoutColumn(layout, false);
1311         filter = RNA_enum_get(ptr, "filter_type");
1312         reference = RNA_boolean_get(ptr, "use_variable_size");
1313
1314         uiItemR(col, ptr, "filter_type", 0, "", ICON_NONE);
1315         if (filter != R_FILTER_FAST_GAUSS) {
1316                 uiItemR(col, ptr, "use_variable_size", 0, NULL, ICON_NONE);
1317                 if (!reference) {
1318                         uiItemR(col, ptr, "use_bokeh", 0, NULL, ICON_NONE);
1319                 }
1320                 uiItemR(col, ptr, "use_gamma_correction", 0, NULL, ICON_NONE);
1321         }
1322         
1323         uiItemR(col, ptr, "use_relative", 0, NULL, ICON_NONE);
1324         
1325         if (RNA_boolean_get(ptr, "use_relative")) {
1326                 uiItemL(col, IFACE_("Aspect Correction"), ICON_NONE);
1327                 row = uiLayoutRow(layout, true);
1328                 uiItemR(row, ptr, "aspect_correction", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1329                 
1330                 col = uiLayoutColumn(layout, true);
1331                 uiItemR(col, ptr, "factor_x", 0, IFACE_("X"), ICON_NONE);
1332                 uiItemR(col, ptr, "factor_y", 0, IFACE_("Y"), ICON_NONE);
1333         }
1334         else {
1335                 col = uiLayoutColumn(layout, true);
1336                 uiItemR(col, ptr, "size_x", 0, IFACE_("X"), ICON_NONE);
1337                 uiItemR(col, ptr, "size_y", 0, IFACE_("Y"), ICON_NONE);
1338         }
1339         uiItemR(col, ptr, "use_extended_bounds", 0, NULL, ICON_NONE);
1340 }
1341
1342 static void node_composit_buts_dblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1343 {
1344         uiLayout *col;
1345         
1346         uiItemR(layout, ptr, "iterations", 0, NULL, ICON_NONE);
1347         uiItemR(layout, ptr, "use_wrap", 0, NULL, ICON_NONE);
1348         
1349         col = uiLayoutColumn(layout, true);
1350         uiItemL(col, IFACE_("Center:"), ICON_NONE);
1351         uiItemR(col, ptr, "center_x", 0, IFACE_("X"), ICON_NONE);
1352         uiItemR(col, ptr, "center_y", 0, IFACE_("Y"), ICON_NONE);
1353         
1354         uiItemS(layout);
1355         
1356         col = uiLayoutColumn(layout, true);
1357         uiItemR(col, ptr, "distance", 0, NULL, ICON_NONE);
1358         uiItemR(col, ptr, "angle", 0, NULL, ICON_NONE);
1359         
1360         uiItemS(layout);
1361         
1362         uiItemR(layout, ptr, "spin", 0, NULL, ICON_NONE);
1363         uiItemR(layout, ptr, "zoom", 0, NULL, ICON_NONE);
1364 }
1365
1366 static void node_composit_buts_bilateralblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1367 {       
1368         uiLayout *col;
1369         
1370         col = uiLayoutColumn(layout, true);
1371         uiItemR(col, ptr, "iterations", 0, NULL, ICON_NONE);
1372         uiItemR(col, ptr, "sigma_color", 0, NULL, ICON_NONE);
1373         uiItemR(col, ptr, "sigma_space", 0, NULL, ICON_NONE);
1374 }
1375
1376 static void node_composit_buts_defocus(uiLayout *layout, bContext *C, PointerRNA *ptr)
1377 {
1378         uiLayout *sub, *col;
1379         
1380         col = uiLayoutColumn(layout, false);
1381         uiItemL(col, IFACE_("Bokeh Type:"), ICON_NONE);
1382         uiItemR(col, ptr, "bokeh", 0, "", ICON_NONE);
1383         uiItemR(col, ptr, "angle", 0, NULL, ICON_NONE);
1384
1385         uiItemR(layout, ptr, "use_gamma_correction", 0, NULL, ICON_NONE);
1386
1387         col = uiLayoutColumn(layout, false);
1388         uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_zbuffer") == true);
1389         uiItemR(col, ptr, "f_stop", 0, NULL, ICON_NONE);
1390
1391         uiItemR(layout, ptr, "blur_max", 0, NULL, ICON_NONE);
1392         uiItemR(layout, ptr, "threshold", 0, NULL, ICON_NONE);
1393
1394         col = uiLayoutColumn(layout, false);
1395         uiItemR(col, ptr, "use_preview", 0, NULL, ICON_NONE);
1396
1397         uiTemplateID(layout, C, ptr, "scene", NULL, NULL, NULL);
1398
1399         col = uiLayoutColumn(layout, false);
1400         uiItemR(col, ptr, "use_zbuffer", 0, NULL, ICON_NONE);
1401         sub = uiLayoutColumn(col, false);
1402         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_zbuffer") == false);
1403         uiItemR(sub, ptr, "z_scale", 0, NULL, ICON_NONE);
1404 }
1405
1406 /* qdn: glare node */
1407 static void node_composit_buts_glare(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1408 {       
1409         uiItemR(layout, ptr, "glare_type", 0, "", ICON_NONE);
1410         uiItemR(layout, ptr, "quality", 0, "", ICON_NONE);
1411
1412         if (RNA_enum_get(ptr, "glare_type") != 1) {
1413                 uiItemR(layout, ptr, "iterations", 0, NULL, ICON_NONE);
1414         
1415                 if (RNA_enum_get(ptr, "glare_type") != 0)
1416                         uiItemR(layout, ptr, "color_modulation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1417         }
1418         
1419         uiItemR(layout, ptr, "mix", 0, NULL, ICON_NONE);
1420         uiItemR(layout, ptr, "threshold", 0, NULL, ICON_NONE);
1421
1422         if (RNA_enum_get(ptr, "glare_type") == 2) {
1423                 uiItemR(layout, ptr, "streaks", 0, NULL, ICON_NONE);
1424                 uiItemR(layout, ptr, "angle_offset", 0, NULL, ICON_NONE);
1425         }
1426         if (RNA_enum_get(ptr, "glare_type") == 0 || RNA_enum_get(ptr, "glare_type") == 2) {
1427                 uiItemR(layout, ptr, "fade", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1428                 
1429                 if (RNA_enum_get(ptr, "glare_type") == 0)
1430                         uiItemR(layout, ptr, "use_rotate_45", 0, NULL, ICON_NONE);
1431         }
1432         if (RNA_enum_get(ptr, "glare_type") == 1) {
1433                 uiItemR(layout, ptr, "size", 0, NULL, ICON_NONE);
1434         }
1435 }
1436
1437 static void node_composit_buts_tonemap(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1438 {       
1439         uiLayout *col;
1440
1441         col = uiLayoutColumn(layout, false);
1442         uiItemR(col, ptr, "tonemap_type", 0, "", ICON_NONE);
1443         if (RNA_enum_get(ptr, "tonemap_type") == 0) {
1444                 uiItemR(col, ptr, "key", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1445                 uiItemR(col, ptr, "offset", 0, NULL, ICON_NONE);
1446                 uiItemR(col, ptr, "gamma", 0, NULL, ICON_NONE);
1447         }
1448         else {
1449                 uiItemR(col, ptr, "intensity", 0, NULL, ICON_NONE);
1450                 uiItemR(col, ptr, "contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1451                 uiItemR(col, ptr, "adaptation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1452                 uiItemR(col, ptr, "correction", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1453         }
1454 }
1455
1456 static void node_composit_buts_lensdist(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1457 {
1458         uiLayout *col;
1459
1460         col = uiLayoutColumn(layout, false);
1461         uiItemR(col, ptr, "use_projector", 0, NULL, ICON_NONE);
1462
1463         col = uiLayoutColumn(col, false);
1464         uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_projector") == false);
1465         uiItemR(col, ptr, "use_jitter", 0, NULL, ICON_NONE);
1466         uiItemR(col, ptr, "use_fit", 0, NULL, ICON_NONE);
1467 }
1468
1469 static void node_composit_buts_vecblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1470 {
1471         uiLayout *col;
1472         
1473         col = uiLayoutColumn(layout, false);
1474         uiItemR(col, ptr, "samples", 0, NULL, ICON_NONE);
1475         uiItemR(col, ptr, "factor", 0, IFACE_("Blur"), ICON_NONE);
1476         
1477         col = uiLayoutColumn(layout, true);
1478         uiItemL(col, IFACE_("Speed:"), ICON_NONE);
1479         uiItemR(col, ptr, "speed_min", 0, IFACE_("Min"), ICON_NONE);
1480         uiItemR(col, ptr, "speed_max", 0, IFACE_("Max"), ICON_NONE);
1481
1482         uiItemR(layout, ptr, "use_curved", 0, NULL, ICON_NONE);
1483 }
1484
1485 static void node_composit_buts_filter(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1486 {
1487         uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
1488 }
1489
1490 static void node_composit_buts_flip(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1491 {
1492         uiItemR(layout, ptr, "axis", 0, "", ICON_NONE);
1493 }
1494
1495 static void node_composit_buts_crop(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1496 {
1497         uiLayout *col;
1498
1499         uiItemR(layout, ptr, "use_crop_size", 0, NULL, ICON_NONE);
1500         uiItemR(layout, ptr, "relative", 0, NULL, ICON_NONE);
1501
1502         col = uiLayoutColumn(layout, true);
1503         if (RNA_boolean_get(ptr, "relative")) {
1504                 uiItemR(col, ptr, "rel_min_x", 0, IFACE_("Left"), ICON_NONE);
1505                 uiItemR(col, ptr, "rel_max_x", 0, IFACE_("Right"), ICON_NONE);
1506                 uiItemR(col, ptr, "rel_min_y", 0, IFACE_("Up"), ICON_NONE);
1507                 uiItemR(col, ptr, "rel_max_y", 0, IFACE_("Down"), ICON_NONE);
1508         }
1509         else {
1510                 uiItemR(col, ptr, "min_x", 0, IFACE_("Left"), ICON_NONE);
1511                 uiItemR(col, ptr, "max_x", 0, IFACE_("Right"), ICON_NONE);
1512                 uiItemR(col, ptr, "min_y", 0, IFACE_("Up"), ICON_NONE);
1513                 uiItemR(col, ptr, "max_y", 0, IFACE_("Down"), ICON_NONE);
1514         }
1515 }
1516
1517 static void node_composit_buts_splitviewer(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1518 {
1519         uiLayout *row, *col;
1520         
1521         col = uiLayoutColumn(layout, false);
1522         row = uiLayoutRow(col, false);
1523         uiItemR(row, ptr, "axis", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1524         uiItemR(col, ptr, "factor", 0, NULL, ICON_NONE);
1525 }
1526
1527 static void node_composit_buts_double_edge_mask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1528 {
1529         uiLayout *col;
1530
1531         col = uiLayoutColumn(layout, false);
1532
1533         uiItemL(col, IFACE_("Inner Edge:"), ICON_NONE);
1534         uiItemR(col, ptr, "inner_mode", 0, "", ICON_NONE);
1535         uiItemL(col, IFACE_("Buffer Edge:"), ICON_NONE);
1536         uiItemR(col, ptr, "edge_mode", 0, "", ICON_NONE);
1537 }
1538
1539 static void node_composit_buts_map_range(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1540 {
1541         uiLayout *col;
1542
1543         col = uiLayoutColumn(layout, true);
1544         uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
1545 }
1546
1547 static void node_composit_buts_map_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1548 {
1549         uiLayout *sub, *col;
1550         
1551         col = uiLayoutColumn(layout, true);
1552         uiItemR(col, ptr, "offset", 0, NULL, ICON_NONE);
1553         uiItemR(col, ptr, "size", 0, NULL, ICON_NONE);
1554         
1555         col = uiLayoutColumn(layout, true);
1556         uiItemR(col, ptr, "use_min", 0, NULL, ICON_NONE);
1557         sub = uiLayoutColumn(col, false);
1558         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_min"));
1559         uiItemR(sub, ptr, "min", 0, "", ICON_NONE);
1560         
1561         col = uiLayoutColumn(layout, true);
1562         uiItemR(col, ptr, "use_max", 0, NULL, ICON_NONE);
1563         sub = uiLayoutColumn(col, false);
1564         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_max"));
1565         uiItemR(sub, ptr, "max", 0, "", ICON_NONE);
1566 }
1567
1568 static void node_composit_buts_alphaover(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1569 {       
1570         uiLayout *col;
1571         
1572         col = uiLayoutColumn(layout, true);
1573         uiItemR(col, ptr, "use_premultiply", 0, NULL, ICON_NONE);
1574         uiItemR(col, ptr, "premul", 0, NULL, ICON_NONE);
1575 }
1576
1577 static void node_composit_buts_zcombine(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1578 {       
1579         uiLayout *col;
1580         
1581         col = uiLayoutColumn(layout, true);
1582         uiItemR(col, ptr, "use_alpha", 0, NULL, ICON_NONE);
1583         uiItemR(col, ptr, "use_antialias_z", 0, NULL, ICON_NONE);
1584 }
1585
1586 static void node_composit_buts_dilateerode(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1587 {
1588         uiItemR(layout, ptr, "mode", 0, NULL, ICON_NONE);
1589         uiItemR(layout, ptr, "distance", 0, NULL, ICON_NONE);
1590         switch (RNA_enum_get(ptr, "mode")) {
1591                 case CMP_NODE_DILATEERODE_DISTANCE_THRESH:
1592                         uiItemR(layout, ptr, "edge", 0, NULL, ICON_NONE);
1593                         break;
1594                 case CMP_NODE_DILATEERODE_DISTANCE_FEATHER:
1595                         uiItemR(layout, ptr, "falloff", 0, NULL, ICON_NONE);
1596                         break;
1597         }
1598 }
1599
1600 static void node_composit_buts_inpaint(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1601 {
1602         uiItemR(layout, ptr, "distance", 0, NULL, ICON_NONE);
1603 }
1604
1605 static void node_composit_buts_despeckle(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1606 {
1607         uiLayout *col;
1608
1609         col = uiLayoutColumn(layout, false);
1610         uiItemR(col, ptr, "threshold", 0, NULL, ICON_NONE);
1611         uiItemR(col, ptr, "threshold_neighbor", 0, NULL, ICON_NONE);
1612 }
1613
1614 static void node_composit_buts_diff_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1615 {
1616         uiLayout *col;
1617         
1618         col = uiLayoutColumn(layout, true);
1619         uiItemR(col, ptr, "tolerance", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1620         uiItemR(col, ptr, "falloff", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1621 }
1622
1623 static void node_composit_buts_distance_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1624 {
1625         uiLayout *col, *row;
1626         
1627         col = uiLayoutColumn(layout, true);
1628
1629         uiItemL(layout, IFACE_("Color Space:"), ICON_NONE);
1630         row = uiLayoutRow(layout, false);
1631         uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1632
1633         uiItemR(col, ptr, "tolerance", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1634         uiItemR(col, ptr, "falloff", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1635 }
1636
1637 static void node_composit_buts_color_spill(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1638 {
1639         uiLayout *row, *col;
1640         
1641         uiItemL(layout, IFACE_("Despill Channel:"), ICON_NONE);
1642         row = uiLayoutRow(layout, false);
1643         uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1644
1645         col = uiLayoutColumn(layout, false);
1646         uiItemR(col, ptr, "limit_method", 0, NULL, ICON_NONE);
1647
1648         if (RNA_enum_get(ptr, "limit_method") == 0) {
1649                 uiItemL(col, IFACE_("Limiting Channel:"), ICON_NONE);
1650                 row = uiLayoutRow(col, false);
1651                 uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1652         }
1653
1654         uiItemR(col, ptr, "ratio", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1655         uiItemR(col, ptr, "use_unspill", 0, NULL, ICON_NONE);
1656         if (RNA_boolean_get(ptr, "use_unspill") == true) {
1657                 uiItemR(col, ptr, "unspill_red", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1658                 uiItemR(col, ptr, "unspill_green", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1659                 uiItemR(col, ptr, "unspill_blue", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1660         }
1661 }
1662
1663 static void node_composit_buts_chroma_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1664 {
1665         uiLayout *col;
1666         
1667         col = uiLayoutColumn(layout, false);
1668         uiItemR(col, ptr, "tolerance", 0, NULL, ICON_NONE);
1669         uiItemR(col, ptr, "threshold", 0, NULL, ICON_NONE);
1670         
1671         col = uiLayoutColumn(layout, true);
1672         /*uiItemR(col, ptr, "lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);  Removed for now */
1673         uiItemR(col, ptr, "gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1674         /*uiItemR(col, ptr, "shadow_adjust", UI_ITEM_R_SLIDER, NULL, ICON_NONE);  Removed for now*/
1675 }
1676
1677 static void node_composit_buts_color_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1678 {
1679         uiLayout *col;
1680         
1681         col = uiLayoutColumn(layout, true);
1682         uiItemR(col, ptr, "color_hue", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1683         uiItemR(col, ptr, "color_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1684         uiItemR(col, ptr, "color_value", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1685 }
1686
1687 static void node_composit_buts_channel_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1688 {       
1689         uiLayout *col, *row;
1690
1691         uiItemL(layout, IFACE_("Color Space:"), ICON_NONE);
1692         row = uiLayoutRow(layout, false);
1693         uiItemR(row, ptr, "color_space", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1694
1695         col = uiLayoutColumn(layout, false);
1696         uiItemL(col, IFACE_("Key Channel:"), ICON_NONE);
1697         row = uiLayoutRow(col, false);
1698         uiItemR(row, ptr, "matte_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1699
1700         col = uiLayoutColumn(layout, false);
1701
1702         uiItemR(col, ptr, "limit_method", 0, NULL, ICON_NONE);
1703         if (RNA_enum_get(ptr, "limit_method") == 0) {
1704                 uiItemL(col, IFACE_("Limiting Channel:"), ICON_NONE);
1705                 row = uiLayoutRow(col, false);
1706                 uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1707         }
1708
1709         uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1710         uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1711 }
1712
1713 static void node_composit_buts_luma_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1714 {
1715         uiLayout *col;
1716         
1717         col = uiLayoutColumn(layout, true);
1718         uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1719         uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1720 }
1721
1722 static void node_composit_buts_map_uv(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1723 {
1724         uiItemR(layout, ptr, "alpha", 0, NULL, ICON_NONE);
1725 }
1726
1727 static void node_composit_buts_id_mask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1728 {
1729         uiItemR(layout, ptr, "index", 0, NULL, ICON_NONE);
1730         uiItemR(layout, ptr, "use_antialiasing", 0, NULL, ICON_NONE);
1731 }
1732
1733 static void node_composit_buts_file_output(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1734 {
1735         PointerRNA imfptr = RNA_pointer_get(ptr, "format");
1736         const bool multilayer = RNA_enum_get(&imfptr, "file_format") == R_IMF_IMTYPE_MULTILAYER;
1737
1738         if (multilayer)
1739                 uiItemL(layout, IFACE_("Path:"), ICON_NONE);
1740         else
1741                 uiItemL(layout, IFACE_("Base Path:"), ICON_NONE);
1742         uiItemR(layout, ptr, "base_path", 0, "", ICON_NONE);
1743 }
1744 static void node_composit_buts_file_output_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1745 {
1746         Scene *scene = CTX_data_scene(C);
1747         PointerRNA imfptr = RNA_pointer_get(ptr, "format");
1748         PointerRNA active_input_ptr, op_ptr;
1749         wmOperatorType *ot;
1750         uiLayout *row, *col;
1751         int active_index;
1752         const bool multilayer = RNA_enum_get(&imfptr, "file_format") == R_IMF_IMTYPE_MULTILAYER;
1753         const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
1754         
1755         node_composit_buts_file_output(layout, C, ptr);
1756         uiTemplateImageSettings(layout, &imfptr, false);
1757         
1758         /* disable stereo output for multilayer, too much work for something that no one will use */
1759         /* if someone asks for that we can implement it */
1760         if (is_multiview)
1761                 uiTemplateImageFormatViews(layout, &imfptr, NULL);
1762
1763         uiItemS(layout);
1764         
1765         uiItemO(layout, IFACE_("Add Input"), ICON_ZOOMIN, "NODE_OT_output_file_add_socket");
1766         
1767         row = uiLayoutRow(layout, false);
1768         col = uiLayoutColumn(row, true);
1769         
1770         active_index = RNA_int_get(ptr, "active_input_index");
1771         /* using different collection properties if multilayer format is enabled */
1772         if (multilayer) {
1773                 uiTemplateList(col, C, "UI_UL_list", "file_output_node", ptr, "layer_slots", ptr, "active_input_index",
1774                                NULL, 0, 0, 0, 0);
1775                 RNA_property_collection_lookup_int(ptr, RNA_struct_find_property(ptr, "layer_slots"),
1776                                                    active_index, &active_input_ptr);
1777         }
1778         else {
1779                 uiTemplateList(col, C, "UI_UL_list", "file_output_node", ptr, "file_slots", ptr, "active_input_index",
1780                                NULL, 0, 0, 0, 0);
1781                 RNA_property_collection_lookup_int(ptr, RNA_struct_find_property(ptr, "file_slots"),
1782                                                    active_index, &active_input_ptr);
1783         }
1784         /* XXX collection lookup does not return the ID part of the pointer, setting this manually here */
1785         active_input_ptr.id.data = ptr->id.data;
1786         
1787         col = uiLayoutColumn(row, true);
1788         ot = WM_operatortype_find("NODE_OT_output_file_move_active_socket", false);
1789         uiItemFullO_ptr(col, ot, "", ICON_TRIA_UP, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1790         RNA_enum_set(&op_ptr, "direction", 1);
1791         uiItemFullO_ptr(col, ot, "", ICON_TRIA_DOWN, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1792         RNA_enum_set(&op_ptr, "direction", 2);
1793         
1794         if (active_input_ptr.data) {
1795                 if (multilayer) {
1796                         col = uiLayoutColumn(layout, true);
1797                         
1798                         uiItemL(col, IFACE_("Layer:"), ICON_NONE);
1799                         row = uiLayoutRow(col, false);
1800                         uiItemR(row, &active_input_ptr, "name", 0, "", ICON_NONE);
1801                         uiItemFullO(row, "NODE_OT_output_file_remove_active_socket", "",
1802                                     ICON_X, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_R_ICON_ONLY, NULL);
1803                 }
1804                 else {
1805                         col = uiLayoutColumn(layout, true);
1806                         
1807                         uiItemL(col, IFACE_("File Subpath:"), ICON_NONE);
1808                         row = uiLayoutRow(col, false);
1809                         uiItemR(row, &active_input_ptr, "path", 0, "", ICON_NONE);
1810                         uiItemFullO(row, "NODE_OT_output_file_remove_active_socket", "",
1811                                     ICON_X, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_R_ICON_ONLY, NULL);
1812                         
1813                         /* format details for individual files */
1814                         imfptr = RNA_pointer_get(&active_input_ptr, "format");
1815                         
1816                         col = uiLayoutColumn(layout, true);
1817                         uiItemL(col, IFACE_("Format:"), ICON_NONE);
1818                         uiItemR(col, &active_input_ptr, "use_node_format", 0, NULL, ICON_NONE);
1819                         
1820                         col = uiLayoutColumn(layout, false);
1821                         uiLayoutSetActive(col, RNA_boolean_get(&active_input_ptr, "use_node_format") == false);
1822                         uiTemplateImageSettings(col, &imfptr, false);
1823
1824                         if (is_multiview)
1825                                 uiTemplateImageFormatViews(layout, &imfptr, NULL);
1826                 }
1827         }
1828 }
1829
1830 static void node_composit_buts_scale(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1831 {
1832         uiItemR(layout, ptr, "space", 0, "", ICON_NONE);
1833
1834         if (RNA_enum_get(ptr, "space") == CMP_SCALE_RENDERPERCENT) {
1835                 uiLayout *row;
1836                 uiItemR(layout, ptr, "frame_method", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1837                 row = uiLayoutRow(layout, true);
1838                 uiItemR(row, ptr, "offset_x", 0, "X", ICON_NONE);
1839                 uiItemR(row, ptr, "offset_y", 0, "Y", ICON_NONE);
1840         }
1841 }
1842
1843 static void node_composit_buts_rotate(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1844 {
1845         uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
1846 }
1847
1848 static void node_composit_buts_invert(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1849 {
1850         uiLayout *col;
1851         
1852         col = uiLayoutColumn(layout, false);
1853         uiItemR(col, ptr, "invert_rgb", 0, NULL, ICON_NONE);
1854         uiItemR(col, ptr, "invert_alpha", 0, NULL, ICON_NONE);
1855 }
1856
1857 static void node_composit_buts_premulkey(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1858 {
1859         uiItemR(layout, ptr, "mapping", 0, "", ICON_NONE);
1860 }
1861
1862 static void node_composit_buts_view_levels(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1863 {
1864         uiItemR(layout, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1865 }
1866
1867 static void node_composit_buts_colorbalance(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1868 {
1869         uiLayout *split, *col, *row;
1870         
1871         uiItemR(layout, ptr, "correction_method", 0, NULL, ICON_NONE);
1872         
1873         if (RNA_enum_get(ptr, "correction_method") == 0) {
1874         
1875                 split = uiLayoutSplit(layout, 0.0f, false);
1876                 col = uiLayoutColumn(split, false);
1877                 uiTemplateColorPicker(col, ptr, "lift", 1, 1, 0, 1);
1878                 row = uiLayoutRow(col, false);
1879                 uiItemR(row, ptr, "lift", 0, NULL, ICON_NONE);
1880                 
1881                 col = uiLayoutColumn(split, false);
1882                 uiTemplateColorPicker(col, ptr, "gamma", 1, 1, 1, 1);
1883                 row = uiLayoutRow(col, false);
1884                 uiItemR(row, ptr, "gamma", 0, NULL, ICON_NONE);
1885                 
1886                 col = uiLayoutColumn(split, false);
1887                 uiTemplateColorPicker(col, ptr, "gain", 1, 1, 1, 1);
1888                 row = uiLayoutRow(col, false);
1889                 uiItemR(row, ptr, "gain", 0, NULL, ICON_NONE);
1890
1891         }
1892         else {
1893                 
1894                 split = uiLayoutSplit(layout, 0.0f, false);
1895                 col = uiLayoutColumn(split, false);
1896                 uiTemplateColorPicker(col, ptr, "offset", 1, 1, 0, 1);
1897                 row = uiLayoutRow(col, false);
1898                 uiItemR(row, ptr, "offset", 0, NULL, ICON_NONE);
1899                 uiItemR(col, ptr, "offset_basis", 0, NULL, ICON_NONE);
1900                 
1901                 col = uiLayoutColumn(split, false);
1902                 uiTemplateColorPicker(col, ptr, "power", 1, 1, 0, 1);
1903                 row = uiLayoutRow(col, false);
1904                 uiItemR(row, ptr, "power", 0, NULL, ICON_NONE);
1905                 
1906                 col = uiLayoutColumn(split, false);
1907                 uiTemplateColorPicker(col, ptr, "slope", 1, 1, 0, 1);
1908                 row = uiLayoutRow(col, false);
1909                 uiItemR(row, ptr, "slope", 0, NULL, ICON_NONE);
1910         }
1911
1912 }
1913 static void node_composit_buts_colorbalance_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1914 {
1915         uiItemR(layout, ptr, "correction_method", 0, NULL, ICON_NONE);
1916
1917         if (RNA_enum_get(ptr, "correction_method") == 0) {
1918
1919                 uiTemplateColorPicker(layout, ptr, "lift", 1, 1, 0, 1);
1920                 uiItemR(layout, ptr, "lift", 0, NULL, ICON_NONE);
1921
1922                 uiTemplateColorPicker(layout, ptr, "gamma", 1, 1, 1, 1);
1923                 uiItemR(layout, ptr, "gamma", 0, NULL, ICON_NONE);
1924
1925                 uiTemplateColorPicker(layout, ptr, "gain", 1, 1, 1, 1);
1926                 uiItemR(layout, ptr, "gain", 0, NULL, ICON_NONE);
1927         }
1928         else {
1929                 uiTemplateColorPicker(layout, ptr, "offset", 1, 1, 0, 1);
1930                 uiItemR(layout, ptr, "offset", 0, NULL, ICON_NONE);
1931
1932                 uiTemplateColorPicker(layout, ptr, "power", 1, 1, 0, 1);
1933                 uiItemR(layout, ptr, "power", 0, NULL, ICON_NONE);
1934
1935                 uiTemplateColorPicker(layout, ptr, "slope", 1, 1, 0, 1);
1936                 uiItemR(layout, ptr, "slope", 0, NULL, ICON_NONE);
1937         }
1938 }
1939
1940
1941 static void node_composit_buts_huecorrect(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1942 {
1943         bNode *node = ptr->data;
1944         CurveMapping *cumap = node->storage;
1945
1946         if (_sample_col[0] != SAMPLE_FLT_ISNONE) {
1947                 cumap->flag |= CUMA_DRAW_SAMPLE;
1948                 copy_v3_v3(cumap->sample, _sample_col);
1949         }
1950         else {
1951                 cumap->flag &= ~CUMA_DRAW_SAMPLE;
1952         }
1953
1954         uiTemplateCurveMapping(layout, ptr, "mapping", 'h', false, false, false);
1955 }
1956
1957 static void node_composit_buts_ycc(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1958
1959         uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
1960 }
1961
1962 static void node_composit_buts_movieclip(uiLayout *layout, bContext *C, PointerRNA *ptr)
1963 {
1964         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
1965 }
1966
1967 static void node_composit_buts_movieclip_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1968 {
1969         bNode *node = ptr->data;
1970         PointerRNA clipptr;
1971
1972         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
1973
1974         if (!node->id)
1975                 return;
1976
1977         clipptr = RNA_pointer_get(ptr, "clip");
1978
1979         uiTemplateColorspaceSettings(layout, &clipptr, "colorspace_settings");
1980 }
1981
1982 static void node_composit_buts_stabilize2d(uiLayout *layout, bContext *C, PointerRNA *ptr)
1983 {
1984         bNode *node = ptr->data;
1985
1986         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
1987
1988         if (!node->id)
1989                 return;
1990
1991         uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
1992         uiItemR(layout, ptr, "invert", 0, NULL, ICON_NONE);
1993 }
1994
1995 static void node_composit_buts_translate(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1996 {
1997         uiItemR(layout, ptr, "use_relative", 0, NULL, ICON_NONE);
1998         uiItemR(layout, ptr, "wrap_axis", 0, NULL, ICON_NONE);
1999 }
2000
2001 static void node_composit_buts_transform(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2002 {
2003         uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
2004 }
2005
2006 static void node_composit_buts_moviedistortion(uiLayout *layout, bContext *C, PointerRNA *ptr)
2007 {
2008         bNode *node = ptr->data;
2009
2010         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
2011
2012         if (!node->id)
2013                 return;
2014
2015         uiItemR(layout, ptr, "distortion_type", 0, "", ICON_NONE);
2016 }
2017
2018 static void node_composit_buts_colorcorrection(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2019 {
2020         uiLayout *row;
2021         
2022         row = uiLayoutRow(layout, false);
2023         uiItemR(row, ptr, "red", 0, NULL, ICON_NONE);
2024         uiItemR(row, ptr, "green", 0, NULL, ICON_NONE);
2025         uiItemR(row, ptr, "blue", 0, NULL, ICON_NONE);
2026
2027         row = uiLayoutRow(layout, false);
2028         uiItemL(row, "", ICON_NONE);
2029         uiItemL(row, IFACE_("Saturation"), ICON_NONE);
2030         uiItemL(row, IFACE_("Contrast"), ICON_NONE);
2031         uiItemL(row, IFACE_("Gamma"), ICON_NONE);
2032         uiItemL(row, IFACE_("Gain"), ICON_NONE);
2033         uiItemL(row, IFACE_("Lift"), ICON_NONE);
2034
2035         row = uiLayoutRow(layout, false);
2036         uiItemL(row, IFACE_("Master"), ICON_NONE);
2037         uiItemR(row, ptr, "master_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2038         uiItemR(row, ptr, "master_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2039         uiItemR(row, ptr, "master_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2040         uiItemR(row, ptr, "master_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2041         uiItemR(row, ptr, "master_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2042
2043         row = uiLayoutRow(layout, false);
2044         uiItemL(row, IFACE_("Highlights"), ICON_NONE);
2045         uiItemR(row, ptr, "highlights_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2046         uiItemR(row, ptr, "highlights_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2047         uiItemR(row, ptr, "highlights_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2048         uiItemR(row, ptr, "highlights_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2049         uiItemR(row, ptr, "highlights_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2050
2051         row = uiLayoutRow(layout, false);
2052         uiItemL(row, IFACE_("Midtones"), ICON_NONE);
2053         uiItemR(row, ptr, "midtones_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2054         uiItemR(row, ptr, "midtones_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2055         uiItemR(row, ptr, "midtones_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2056         uiItemR(row, ptr, "midtones_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2057         uiItemR(row, ptr, "midtones_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2058
2059         row = uiLayoutRow(layout, false);
2060         uiItemL(row, IFACE_("Shadows"), ICON_NONE);
2061         uiItemR(row, ptr, "shadows_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2062         uiItemR(row, ptr, "shadows_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2063         uiItemR(row, ptr, "shadows_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2064         uiItemR(row, ptr, "shadows_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2065         uiItemR(row, ptr, "shadows_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2066
2067         row = uiLayoutRow(layout, false);
2068         uiItemR(row, ptr, "midtones_start", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2069         uiItemR(row, ptr, "midtones_end", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2070 }
2071
2072 static void node_composit_buts_colorcorrection_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2073 {
2074         uiLayout *row;
2075         
2076         row = uiLayoutRow(layout, false);
2077         uiItemR(row, ptr, "red", 0, NULL, ICON_NONE);
2078         uiItemR(row, ptr, "green", 0, NULL, ICON_NONE);
2079         uiItemR(row, ptr, "blue", 0, NULL, ICON_NONE);
2080         row = layout;
2081         uiItemL(row, IFACE_("Saturation"), ICON_NONE);
2082         uiItemR(row, ptr, "master_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2083         uiItemR(row, ptr, "highlights_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2084         uiItemR(row, ptr, "midtones_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2085         uiItemR(row, ptr, "shadows_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2086
2087         uiItemL(row, IFACE_("Contrast"), ICON_NONE);
2088         uiItemR(row, ptr, "master_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2089         uiItemR(row, ptr, "highlights_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2090         uiItemR(row, ptr, "midtones_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2091         uiItemR(row, ptr, "shadows_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2092
2093         uiItemL(row, IFACE_("Gamma"), ICON_NONE);
2094         uiItemR(row, ptr, "master_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2095         uiItemR(row, ptr, "highlights_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2096         uiItemR(row, ptr, "midtones_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2097         uiItemR(row, ptr, "shadows_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2098
2099         uiItemL(row, IFACE_("Gain"), ICON_NONE);
2100         uiItemR(row, ptr, "master_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2101         uiItemR(row, ptr, "highlights_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2102         uiItemR(row, ptr, "midtones_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2103         uiItemR(row, ptr, "shadows_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2104         
2105         uiItemL(row, IFACE_("Lift"), ICON_NONE);
2106         uiItemR(row, ptr, "master_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2107         uiItemR(row, ptr, "highlights_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2108         uiItemR(row, ptr, "midtones_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2109         uiItemR(row, ptr, "shadows_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2110
2111         row = uiLayoutRow(layout, false);
2112         uiItemR(row, ptr, "midtones_start", 0, NULL, ICON_NONE);
2113         uiItemR(row, ptr, "midtones_end", 0, NULL, ICON_NONE);
2114 }
2115
2116 static void node_composit_buts_switch(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2117 {
2118         uiItemR(layout, ptr, "check", 0, NULL, ICON_NONE);
2119 }
2120
2121 static void node_composit_buts_switch_view_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *UNUSED(ptr))
2122 {
2123         uiItemFullO(
2124                 layout, "NODE_OT_switch_view_update",
2125                 "Update Views", ICON_FILE_REFRESH, NULL, WM_OP_INVOKE_DEFAULT, 0, NULL);
2126 }
2127
2128 static void node_composit_buts_boxmask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2129 {
2130         uiLayout *row;
2131         
2132         row = uiLayoutRow(layout, true);
2133         uiItemR(row, ptr, "x", 0, NULL, ICON_NONE);
2134         uiItemR(row, ptr, "y", 0, NULL, ICON_NONE);
2135         
2136         row = uiLayoutRow(layout, true);
2137         uiItemR(row, ptr, "width", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2138         uiItemR(row, ptr, "height", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2139
2140         uiItemR(layout, ptr, "rotation", 0, NULL, ICON_NONE);
2141         uiItemR(layout, ptr, "mask_type", 0, NULL, ICON_NONE);
2142 }
2143
2144 static void node_composit_buts_bokehimage(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2145 {
2146         uiItemR(layout, ptr, "flaps", 0, NULL, ICON_NONE);
2147         uiItemR(layout, ptr, "angle", 0, NULL, ICON_NONE);
2148         uiItemR(layout, ptr, "rounding", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2149         uiItemR(layout, ptr, "catadioptric", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2150         uiItemR(layout, ptr, "shift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2151 }
2152
2153 static void node_composit_buts_bokehblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2154 {
2155         uiItemR(layout, ptr, "use_variable_size", 0, NULL, ICON_NONE);
2156         // uiItemR(layout, ptr, "f_stop", 0, NULL, ICON_NONE);  // UNUSED
2157         uiItemR(layout, ptr, "blur_max", 0, NULL, ICON_NONE);
2158         uiItemR(layout, ptr, "use_extended_bounds", 0, NULL, ICON_NONE);
2159 }
2160
2161 static void node_composit_backdrop_viewer(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2162 {
2163 //      node_composit_backdrop_canvas(snode, backdrop, node, x, y);
2164         if (node->custom1 == 0) {
2165                 const float backdropWidth = backdrop->x;
2166                 const float backdropHeight = backdrop->y;
2167                 const float cx = x + snode->zoom * backdropWidth  * node->custom3;
2168                 const float cy = y + snode->zoom * backdropHeight * node->custom4;
2169                 const float cross_size = 12 * U.pixelsize;
2170
2171                 Gwn_VertFormat *format = immVertexFormat();
2172                 unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
2173
2174                 immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2175
2176                 immUniformColor3f(1.0f, 1.0f, 1.0f);
2177
2178                 immBegin(GWN_PRIM_LINES, 4);
2179                 immVertex2f(pos, cx - cross_size, cy - cross_size);
2180                 immVertex2f(pos, cx + cross_size, cy + cross_size);
2181                 immVertex2f(pos, cx + cross_size, cy - cross_size);
2182                 immVertex2f(pos, cx - cross_size, cy + cross_size);
2183                 immEnd();
2184
2185                 immUnbindProgram();
2186         }
2187 }
2188
2189 static void node_composit_backdrop_boxmask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2190 {
2191         NodeBoxMask *boxmask = node->storage;
2192         const float backdropWidth = backdrop->x;
2193         const float backdropHeight = backdrop->y;
2194         const float aspect = backdropWidth / backdropHeight;
2195         const float rad = -boxmask->rotation;
2196         const float cosine = cosf(rad);
2197         const float sine = sinf(rad);
2198         const float halveBoxWidth = backdropWidth * (boxmask->width / 2.0f);
2199         const float halveBoxHeight = backdropHeight * (boxmask->height / 2.0f) * aspect;
2200
2201         float cx, cy, x1, x2, x3, x4;
2202         float y1, y2, y3, y4;
2203
2204         cx  = x + snode->zoom * backdropWidth * boxmask->x;
2205         cy = y + snode->zoom * backdropHeight * boxmask->y;
2206
2207         x1 = cx - (cosine * halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2208         x2 = cx - (cosine * -halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2209         x3 = cx - (cosine * -halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2210         x4 = cx - (cosine * halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2211         y1 = cy - (-sine * halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2212         y2 = cy - (-sine * -halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2213         y3 = cy - (-sine * -halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2214         y4 = cy - (-sine * halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2215
2216         Gwn_VertFormat *format = immVertexFormat();
2217         unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
2218
2219         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2220
2221         immUniformColor3f(1.0f, 1.0f, 1.0f);
2222
2223         immBegin(GWN_PRIM_LINE_LOOP, 4);
2224         immVertex2f(pos, x1, y1);
2225         immVertex2f(pos, x2, y2);
2226         immVertex2f(pos, x3, y3);
2227         immVertex2f(pos, x4, y4);
2228         immEnd();
2229
2230         immUnbindProgram();
2231 }
2232
2233 static void node_composit_backdrop_ellipsemask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2234 {
2235         NodeEllipseMask *ellipsemask = node->storage;
2236         const float backdropWidth = backdrop->x;
2237         const float backdropHeight = backdrop->y;
2238         const float aspect = backdropWidth / backdropHeight;
2239         const float rad = -ellipsemask->rotation;
2240         const float cosine = cosf(rad);
2241         const float sine = sinf(rad);
2242         const float halveBoxWidth = backdropWidth * (ellipsemask->width / 2.0f);
2243         const float halveBoxHeight = backdropHeight * (ellipsemask->height / 2.0f) * aspect;
2244
2245         float cx, cy, x1, x2, x3, x4;
2246         float y1, y2, y3, y4;
2247
2248         cx  = x + snode->zoom * backdropWidth * ellipsemask->x;
2249         cy = y + snode->zoom * backdropHeight * ellipsemask->y;
2250
2251         x1 = cx - (cosine * halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2252         x2 = cx - (cosine * -halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2253         x3 = cx - (cosine * -halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2254         x4 = cx - (cosine * halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2255         y1 = cy - (-sine * halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2256         y2 = cy - (-sine * -halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2257         y3 = cy - (-sine * -halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2258         y4 = cy - (-sine * halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2259
2260         Gwn_VertFormat *format = immVertexFormat();
2261         unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
2262
2263         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2264
2265         immUniformColor3f(1.0f, 1.0f, 1.0f);
2266
2267         immBegin(GWN_PRIM_LINE_LOOP, 4);
2268         immVertex2f(pos, x1, y1);
2269         immVertex2f(pos, x2, y2);
2270         immVertex2f(pos, x3, y3);
2271         immVertex2f(pos, x4, y4);
2272         immEnd();
2273
2274         immUnbindProgram();
2275 }
2276
2277 static void node_composit_buts_ellipsemask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2278 {
2279         uiLayout *row;
2280         row = uiLayoutRow(layout, true);
2281         uiItemR(row, ptr, "x", 0, NULL, ICON_NONE);
2282         uiItemR(row, ptr, "y", 0, NULL, ICON_NONE);
2283         row = uiLayoutRow(layout, true);
2284         uiItemR(row, ptr, "width", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2285         uiItemR(row, ptr, "height", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2286
2287         uiItemR(layout, ptr, "rotation", 0, NULL, ICON_NONE);
2288         uiItemR(layout, ptr, "mask_type", 0, NULL, ICON_NONE);
2289 }
2290
2291 static void node_composit_buts_composite(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2292 {
2293         uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2294 }
2295
2296 static void node_composit_buts_viewer(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2297 {
2298         uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2299 }
2300
2301 static void node_composit_buts_viewer_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2302 {
2303         uiLayout *col;
2304         
2305         uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2306         uiItemR(layout, ptr, "tile_order", 0, NULL, ICON_NONE);
2307         if (RNA_enum_get(ptr, "tile_order") == 0) {
2308                 col = uiLayoutColumn(layout, true);
2309                 uiItemR(col, ptr, "center_x", 0, NULL, ICON_NONE);
2310                 uiItemR(col, ptr, "center_y", 0, NULL, ICON_NONE);
2311         }
2312 }
2313
2314 static void node_composit_buts_mask(uiLayout *layout, bContext *C, PointerRNA *ptr)
2315 {
2316         bNode *node = ptr->data;
2317
2318         uiTemplateID(layout, C, ptr, "mask", NULL, NULL, NULL);
2319         uiItemR(layout, ptr, "use_antialiasing", 0, NULL, ICON_NONE);
2320         uiItemR(layout, ptr, "use_feather", 0, NULL, ICON_NONE);
2321
2322         uiItemR(layout, ptr, "size_source", 0, "", ICON_NONE);
2323
2324         if (node->custom1 & (CMP_NODEFLAG_MASK_FIXED | CMP_NODEFLAG_MASK_FIXED_SCENE)) {
2325                 uiItemR(layout, ptr, "size_x", 0, NULL, ICON_NONE);
2326                 uiItemR(layout, ptr, "size_y", 0, NULL, ICON_NONE);
2327         }
2328
2329         uiItemR(layout, ptr, "use_motion_blur", 0, NULL, ICON_NONE);
2330         if (node->custom1 & CMP_NODEFLAG_MASK_MOTION_BLUR) {
2331                 uiItemR(layout, ptr, "motion_blur_samples", 0, NULL, ICON_NONE);
2332                 uiItemR(layout, ptr, "motion_blur_shutter", 0, NULL, ICON_NONE);
2333         }
2334 }
2335
2336 static void node_composit_buts_keyingscreen(uiLayout *layout, bContext *C, PointerRNA *ptr)
2337 {
2338         bNode *node = ptr->data;
2339
2340         uiTemplateID(layout, C, ptr, "clip", NULL, NULL, NULL);
2341
2342         if (node->id) {
2343                 MovieClip *clip = (MovieClip *) node->id;
2344                 uiLayout *col;
2345                 PointerRNA tracking_ptr;
2346
2347                 RNA_pointer_create(&clip->id, &RNA_MovieTracking, &clip->tracking, &tracking_ptr);
2348
2349                 col = uiLayoutColumn(layout, true);
2350                 uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2351         }
2352 }
2353
2354 static void node_composit_buts_keying(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2355 {
2356         /* bNode *node = ptr->data; */ /* UNUSED */
2357
2358         uiItemR(layout, ptr, "blur_pre", 0, NULL, ICON_NONE);
2359         uiItemR(layout, ptr, "screen_balance", 0, NULL, ICON_NONE);
2360         uiItemR(layout, ptr, "despill_factor", 0, NULL, ICON_NONE);
2361         uiItemR(layout, ptr, "despill_balance", 0, NULL, ICON_NONE);
2362         uiItemR(layout, ptr, "edge_kernel_radius", 0, NULL, ICON_NONE);
2363         uiItemR(layout, ptr, "edge_kernel_tolerance", 0, NULL, ICON_NONE);
2364         uiItemR(layout, ptr, "clip_black", 0, NULL, ICON_NONE);
2365         uiItemR(layout, ptr, "clip_white", 0, NULL, ICON_NONE);
2366         uiItemR(layout, ptr, "dilate_distance", 0, NULL, ICON_NONE);
2367         uiItemR(layout, ptr, "feather_falloff", 0, NULL, ICON_NONE);
2368         uiItemR(layout, ptr, "feather_distance", 0, NULL, ICON_NONE);
2369         uiItemR(layout, ptr, "blur_post", 0, NULL, ICON_NONE);
2370 }
2371
2372 static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRNA *ptr)
2373 {
2374         bNode *node = ptr->data;
2375
2376         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
2377
2378         if (node->id) {
2379                 MovieClip *clip = (MovieClip *) node->id;
2380                 MovieTracking *tracking = &clip->tracking;
2381                 MovieTrackingObject *object;
2382                 uiLayout *col;
2383                 PointerRNA tracking_ptr;
2384                 NodeTrackPosData *data = node->storage;
2385
2386                 RNA_pointer_create(&clip->id, &RNA_MovieTracking, tracking, &tracking_ptr);
2387
2388                 col = uiLayoutColumn(layout, false);
2389                 uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2390
2391                 object = BKE_tracking_object_get_named(tracking, data->tracking_object);
2392                 if (object) {
2393                         PointerRNA object_ptr;
2394
2395                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
2396
2397                         uiItemPointerR(col, ptr, "track_name", &object_ptr, "tracks", "", ICON_ANIM_DATA);
2398                 }
2399                 else {
2400                         uiItemR(layout, ptr, "track_name", 0, "", ICON_ANIM_DATA);
2401                 }
2402
2403                 uiItemR(layout, ptr, "position", 0, NULL, ICON_NONE);
2404
2405                 if (ELEM(node->custom1, CMP_TRACKPOS_RELATIVE_FRAME, CMP_TRACKPOS_ABSOLUTE_FRAME)) {
2406                         uiItemR(layout, ptr, "frame_relative", 0, NULL, ICON_NONE);
2407                 }
2408         }
2409 }
2410
2411 static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, PointerRNA *ptr)
2412 {
2413         bNode *node = ptr->data;
2414         NodePlaneTrackDeformData *data = node->storage;
2415
2416         uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
2417
2418         if (node->id) {
2419                 MovieClip *clip = (MovieClip *) node->id;
2420                 MovieTracking *tracking = &clip->tracking;
2421                 MovieTrackingObject *object;
2422                 uiLayout *col;
2423                 PointerRNA tracking_ptr;
2424
2425                 RNA_pointer_create(&clip->id, &RNA_MovieTracking, tracking, &tracking_ptr);
2426
2427                 col = uiLayoutColumn(layout, false);
2428                 uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2429
2430                 object = BKE_tracking_object_get_named(tracking, data->tracking_object);
2431                 if (object) {
2432                         PointerRNA object_ptr;
2433
2434                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
2435
2436                         uiItemPointerR(col, ptr, "plane_track_name", &object_ptr, "plane_tracks", "", ICON_ANIM_DATA);
2437                 }
2438                 else {
2439                         uiItemR(layout, ptr, "plane_track_name", 0, "", ICON_ANIM_DATA);
2440                 }
2441         }
2442
2443         uiItemR(layout, ptr, "use_motion_blur", 0, NULL, ICON_NONE);
2444         if (data->flag & CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR) {
2445                 uiItemR(layout, ptr, "motion_blur_samples", 0, NULL, ICON_NONE);
2446                 uiItemR(layout, ptr, "motion_blur_shutter", 0, NULL, ICON_NONE);
2447         }
2448 }
2449
2450 static void node_composit_buts_cornerpin(uiLayout *UNUSED(layout), bContext *UNUSED(C), PointerRNA *UNUSED(ptr))
2451 {
2452 }
2453
2454 static void node_composit_buts_sunbeams(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2455 {
2456         uiItemR(layout, ptr, "source", UI_ITEM_R_EXPAND, "", ICON_NONE);
2457         uiItemR(layout, ptr, "ray_length", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2458 }
2459
2460 static void node_composit_buts_brightcontrast(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2461 {
2462         uiItemR(layout, ptr, "use_premultiply", 0, NULL, ICON_NONE);
2463 }
2464
2465 /* only once called */
2466 static void node_composit_set_butfunc(bNodeType *ntype)
2467 {
2468         switch (ntype->type) {
2469                 case CMP_NODE_IMAGE:
2470                         ntype->draw_buttons = node_composit_buts_image;
2471                         ntype->draw_buttons_ex = node_composit_buts_image_ex;
2472                         break;
2473                 case CMP_NODE_R_LAYERS:
2474                         ntype->draw_buttons = node_composit_buts_renderlayers;
2475                         break;
2476                 case CMP_NODE_NORMAL:
2477                         ntype->draw_buttons = node_buts_normal;
2478                         break;
2479                 case CMP_NODE_CURVE_VEC:
2480                         ntype->draw_buttons = node_buts_curvevec;
2481                         break;
2482                 case CMP_NODE_CURVE_RGB:
2483                         ntype->draw_buttons = node_buts_curvecol;
2484                         break;
2485                 case CMP_NODE_VALUE:
2486                         ntype->draw_buttons = node_buts_value;
2487                         break;
2488                 case CMP_NODE_RGB:
2489                         ntype->draw_buttons = node_buts_rgb;
2490                         break;
2491                 case CMP_NODE_FLIP:
2492                         ntype->draw_buttons = node_composit_buts_flip;
2493                         break;
2494                 case CMP_NODE_SPLITVIEWER:
2495                         ntype->draw_buttons = node_composit_buts_splitviewer;
2496                         break;
2497                 case CMP_NODE_MIX_RGB:
2498                         ntype->draw_buttons = node_buts_mix_rgb;
2499                         break;
2500                 case CMP_NODE_VALTORGB:
2501                         ntype->draw_buttons = node_buts_colorramp;
2502                         break;
2503                 case CMP_NODE_CROP:
2504                         ntype->draw_buttons = node_composit_buts_crop;
2505                         break;
2506                 case CMP_NODE_BLUR:
2507                         ntype->draw_buttons = node_composit_buts_blur;
2508                         break;
2509                 case CMP_NODE_DBLUR:
2510                         ntype->draw_buttons = node_composit_buts_dblur;
2511                         break;
2512                 case CMP_NODE_BILATERALBLUR:
2513                         ntype->draw_buttons = node_composit_buts_bilateralblur;
2514                         break;
2515                 case CMP_NODE_DEFOCUS:
2516                         ntype->draw_buttons = node_composit_buts_defocus;
2517                         break;
2518                 case CMP_NODE_GLARE:
2519                         ntype->draw_buttons = node_composit_buts_glare;
2520                         break;
2521                 case CMP_NODE_TONEMAP:
2522                         ntype->draw_buttons = node_composit_buts_tonemap;
2523                         break;
2524                 case CMP_NODE_LENSDIST:
2525                         ntype->draw_buttons = node_composit_buts_lensdist;
2526                         break;
2527                 case CMP_NODE_VECBLUR:
2528                         ntype->draw_buttons = node_composit_buts_vecblur;
2529                         break;
2530                 case CMP_NODE_FILTER:
2531                         ntype->draw_buttons = node_composit_buts_filter;
2532                         break;
2533                 case CMP_NODE_MAP_VALUE:
2534                         ntype->draw_buttons = node_composit_buts_map_value;
2535                         break;
2536                 case CMP_NODE_MAP_RANGE:
2537                         ntype->draw_buttons = node_composit_buts_map_range;
2538                         break;
2539                 case CMP_NODE_TIME:
2540                         ntype->draw_buttons = node_buts_time;
2541                         break;
2542                 case CMP_NODE_ALPHAOVER:
2543                         ntype->draw_buttons = node_composit_buts_alphaover;
2544                         break;
2545                 case CMP_NODE_TEXTURE:
2546                         ntype->draw_buttons = node_buts_texture;
2547                         break;
2548                 case CMP_NODE_DILATEERODE:
2549                         ntype->draw_buttons = node_composit_buts_dilateerode;
2550                         break;
2551                 case CMP_NODE_INPAINT:
2552                         ntype->draw_buttons = node_composit_buts_inpaint;
2553                         break;
2554                 case CMP_NODE_DESPECKLE:
2555                         ntype->draw_buttons = node_composit_buts_despeckle;
2556                         break;
2557                 case CMP_NODE_OUTPUT_FILE:
2558                         ntype->draw_buttons = node_composit_buts_file_output;
2559                         ntype->draw_buttons_ex = node_composit_buts_file_output_ex;
2560                         break;
2561                 case CMP_NODE_DIFF_MATTE:
2562                         ntype->draw_buttons = node_composit_buts_diff_matte;
2563                         break;
2564                 case CMP_NODE_DIST_MATTE:
2565                         ntype->draw_buttons = node_composit_buts_distance_matte;
2566                         break;
2567                 case CMP_NODE_COLOR_SPILL:
2568                         ntype->draw_buttons = node_composit_buts_color_spill;
2569                         break;
2570                 case CMP_NODE_CHROMA_MATTE:
2571                         ntype->draw_buttons = node_composit_buts_chroma_matte;
2572                         break;
2573                 case CMP_NODE_COLOR_MATTE:
2574                         ntype->draw_buttons = node_composit_buts_color_matte;
2575                         break;
2576                 case CMP_NODE_SCALE:
2577                         ntype->draw_buttons = node_composit_buts_scale;
2578                         break;
2579                 case CMP_NODE_ROTATE:
2580                         ntype->draw_buttons = node_composit_buts_rotate;
2581                         break;
2582                 case CMP_NODE_CHANNEL_MATTE:
2583                         ntype->draw_buttons = node_composit_buts_channel_matte;
2584                         break;
2585                 case CMP_NODE_LUMA_MATTE:
2586                         ntype->draw_buttons = node_composit_buts_luma_matte;
2587                         break;
2588                 case CMP_NODE_MAP_UV:
2589                         ntype->draw_buttons = node_composit_buts_map_uv;
2590                         break;
2591                 case CMP_NODE_ID_MASK:
2592                         ntype->draw_buttons = node_composit_buts_id_mask;
2593                         break;
2594                 case CMP_NODE_DOUBLEEDGEMASK:
2595                         ntype->draw_buttons = node_composit_buts_double_edge_mask;
2596                         break;
2597                 case CMP_NODE_MATH:
2598                         ntype->draw_buttons = node_buts_math;
2599                         break;
2600                 case CMP_NODE_INVERT:
2601                         ntype->draw_buttons = node_composit_buts_invert;
2602                         break;
2603                 case CMP_NODE_PREMULKEY:
2604                         ntype->draw_buttons = node_composit_buts_premulkey;
2605                         break;
2606                 case CMP_NODE_VIEW_LEVELS:
2607                         ntype->draw_buttons = node_composit_buts_view_levels;
2608                         break;
2609                 case CMP_NODE_COLORBALANCE:
2610                         ntype->draw_buttons = node_composit_buts_colorbalance;
2611                         ntype->draw_buttons_ex = node_composit_buts_colorbalance_ex;
2612                         break;
2613                 case CMP_NODE_HUECORRECT:
2614                         ntype->draw_buttons = node_composit_buts_huecorrect;
2615                         break;
2616                 case CMP_NODE_ZCOMBINE:
2617                         ntype->draw_buttons = node_composit_buts_zcombine;
2618                         break;
2619                 case CMP_NODE_COMBYCCA:
2620                 case CMP_NODE_SEPYCCA:
2621                         ntype->draw_buttons = node_composit_buts_ycc;
2622                         break;
2623                 case CMP_NODE_MOVIECLIP:
2624                         ntype->draw_buttons = node_composit_buts_movieclip;
2625                         ntype->draw_buttons_ex = node_composit_buts_movieclip_ex;
2626                         break;
2627                 case CMP_NODE_STABILIZE2D:
2628                         ntype->draw_buttons = node_composit_buts_stabilize2d;
2629                         break;
2630                 case CMP_NODE_TRANSFORM:
2631                         ntype->draw_buttons = node_composit_buts_transform;
2632                         break;
2633                 case CMP_NODE_TRANSLATE:
2634                         ntype->draw_buttons = node_composit_buts_translate;
2635                         break;
2636                 case CMP_NODE_MOVIEDISTORTION:
2637                         ntype->draw_buttons = node_composit_buts_moviedistortion;
2638                         break;
2639                 case CMP_NODE_COLORCORRECTION:
2640                         ntype->draw_buttons = node_composit_buts_colorcorrection;
2641                         ntype->draw_buttons_ex = node_composit_buts_colorcorrection_ex;
2642                         break;
2643                 case CMP_NODE_SWITCH:
2644                         ntype->draw_buttons = node_composit_buts_switch;
2645                         break;
2646                 case CMP_NODE_SWITCH_VIEW:
2647                         ntype->draw_buttons_ex = node_composit_buts_switch_view_ex;
2648                         break;
2649                 case CMP_NODE_MASK_BOX:
2650                         ntype->draw_buttons = node_composit_buts_boxmask;
2651                         ntype->draw_backdrop = node_composit_backdrop_boxmask;
2652                         break;
2653                 case CMP_NODE_MASK_ELLIPSE:
2654                         ntype->draw_buttons = node_composit_buts_ellipsemask;
2655                         ntype->draw_backdrop = node_composit_backdrop_ellipsemask;
2656                         break;
2657                 case CMP_NODE_BOKEHIMAGE:
2658                         ntype->draw_buttons = node_composit_buts_bokehimage;
2659                         break;
2660                 case CMP_NODE_BOKEHBLUR:
2661                         ntype->draw_buttons = node_composit_buts_bokehblur;
2662                         break;
2663                 case CMP_NODE_VIEWER:
2664                         ntype->draw_buttons = node_composit_buts_viewer;
2665                         ntype->draw_buttons_ex = node_composit_buts_viewer_ex;
2666                         ntype->draw_backdrop = node_composit_backdrop_viewer;
2667                         break;
2668                 case CMP_NODE_COMPOSITE:
2669                         ntype->draw_buttons = node_composit_buts_composite;
2670                         break;
2671                 case CMP_NODE_MASK:
2672                         ntype->draw_buttons = node_composit_buts_mask;
2673                         break;
2674                 case CMP_NODE_KEYINGSCREEN:
2675                         ntype->draw_buttons = node_composit_buts_keyingscreen;
2676                         break;
2677                 case CMP_NODE_KEYING:
2678                         ntype->draw_buttons = node_composit_buts_keying;
2679                         break;
2680                 case CMP_NODE_TRACKPOS:
2681                         ntype->draw_buttons = node_composit_buts_trackpos;
2682                         break;
2683                 case CMP_NODE_PLANETRACKDEFORM:
2684                         ntype->draw_buttons = node_composit_buts_planetrackdeform;
2685                         break;
2686                 case CMP_NODE_CORNERPIN:
2687                         ntype->draw_buttons = node_composit_buts_cornerpin;
2688                         break;
2689                 case CMP_NODE_SUNBEAMS:
2690                         ntype->draw_buttons = node_composit_buts_sunbeams;
2691                         break;
2692                 case CMP_NODE_BRIGHTCONTRAST:
2693                         ntype->draw_buttons = node_composit_buts_brightcontrast;
2694         }
2695 }
2696
2697 /* ****************** BUTTON CALLBACKS FOR TEXTURE NODES ***************** */
2698
2699 static void node_texture_buts_bricks(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2700 {
2701         uiLayout *col;
2702         
2703         col = uiLayoutColumn(layout, true);
2704         uiItemR(col, ptr, "offset", UI_ITEM_R_SLIDER, IFACE_("Offset"), ICON_NONE);
2705         uiItemR(col, ptr, "offset_frequency", 0, IFACE_("Frequency"), ICON_NONE);
2706         
2707         col = uiLayoutColumn(layout, true);
2708         uiItemR(col, ptr, "squash", 0, IFACE_("Squash"), ICON_NONE);
2709         uiItemR(col, ptr, "squash_frequency", 0, IFACE_("Frequency"), ICON_NONE);
2710 }
2711
2712 static void node_texture_buts_proc(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2713 {
2714         PointerRNA tex_ptr;
2715         bNode *node = ptr->data;
2716         ID *id = ptr->id.data;
2717         Tex *tex = (Tex *)node->storage;
2718         uiLayout *col, *row;
2719         
2720         RNA_pointer_create(id, &RNA_Texture, tex, &tex_ptr);
2721
2722         col = uiLayoutColumn(layout, false);
2723
2724         switch (tex->type) {
2725                 case TEX_BLEND:
2726                         uiItemR(col, &tex_ptr, "progression", 0, "", ICON_NONE);
2727                         row = uiLayoutRow(col, false);
2728                         uiItemR(row, &tex_ptr, "use_flip_axis", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2729                         break;
2730
2731                 case TEX_MARBLE:
2732                         row = uiLayoutRow(col, false);
2733                         uiItemR(row, &tex_ptr, "marble_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2734                         row = uiLayoutRow(col, false);
2735                         uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2736                         row = uiLayoutRow(col, false);
2737                         uiItemR(row, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2738                         row = uiLayoutRow(col, false);
2739                         uiItemR(row, &tex_ptr, "noise_basis_2", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2740                         break;
2741
2742                 case TEX_MAGIC:
2743                         uiItemR(col, &tex_ptr, "noise_depth", 0, NULL, ICON_NONE);
2744                         break;
2745
2746                 case TEX_STUCCI:
2747                         row = uiLayoutRow(col, false);
2748                         uiItemR(row, &tex_ptr, "stucci_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2749                         row = uiLayoutRow(col, false);
2750                         uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2751                         uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2752                         break;
2753
2754                 case TEX_WOOD:
2755                         uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2756                         uiItemR(col, &tex_ptr, "wood_type", 0, "", ICON_NONE);
2757                         row = uiLayoutRow(col, false);
2758                         uiItemR(row, &tex_ptr, "noise_basis_2", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2759                         row = uiLayoutRow(col, false);
2760                         uiLayoutSetActive(row, !(ELEM(tex->stype, TEX_BAND, TEX_RING)));
2761                         uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2762                         break;
2763                         
2764                 case TEX_CLOUDS:
2765                         uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2766                         row = uiLayoutRow(col, false);
2767                         uiItemR(row, &tex_ptr, "cloud_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2768                         row = uiLayoutRow(col, false);
2769                         uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2770                         uiItemR(col, &tex_ptr, "noise_depth", UI_ITEM_R_EXPAND, IFACE_("Depth"), ICON_NONE);
2771                         break;
2772                         
2773                 case TEX_DISTNOISE:
2774                         uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2775                         uiItemR(col, &tex_ptr, "noise_distortion", 0, "", ICON_NONE);
2776                         break;
2777
2778                 case TEX_MUSGRAVE:
2779                         uiItemR(col, &tex_ptr, "musgrave_type", 0, "", ICON_NONE);
2780                         uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2781                         break;
2782                 case TEX_VORONOI:
2783                         uiItemR(col, &tex_ptr, "distance_metric", 0, "", ICON_NONE);
2784                         if (tex->vn_distm == TEX_MINKOVSKY) {
2785                                 uiItemR(col, &tex_ptr, "minkovsky_exponent", 0, NULL, ICON_NONE);
2786                         }
2787                         uiItemR(col, &tex_ptr, "color_mode", 0, "", ICON_NONE);
2788                         break;
2789         }
2790 }
2791
2792 static void node_texture_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
2793 {
2794         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
2795 }
2796
2797 static void node_texture_buts_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
2798 {
2799         bNode *node = ptr->data;
2800         PointerRNA iuserptr;
2801
2802         RNA_pointer_create((ID *)ptr->id.data, &RNA_ImageUser, node->storage, &iuserptr);
2803         uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 0);
2804 }
2805
2806 static void node_texture_buts_output(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2807 {
2808         uiItemR(layout, ptr, "filepath", 0, "", ICON_NONE);
2809 }
2810
2811 /* only once called */
2812 static void node_texture_set_butfunc(bNodeType *ntype)
2813 {
2814         if (ntype->type >= TEX_NODE_PROC && ntype->type < TEX_NODE_PROC_MAX) {
2815                 ntype->draw_buttons = node_texture_buts_proc;
2816         }
2817         else {
2818                 switch (ntype->type) {
2819
2820                         case TEX_NODE_MATH:
2821                                 ntype->draw_buttons = node_buts_math;
2822                                 break;
2823
2824                         case TEX_NODE_MIX_RGB:
2825                                 ntype->draw_buttons = node_buts_mix_rgb;
2826                                 break;
2827
2828                         case TEX_NODE_VALTORGB:
2829                                 ntype->draw_buttons = node_buts_colorramp;
2830                                 break;
2831
2832                         case TEX_NODE_CURVE_RGB:
2833                                 ntype->draw_buttons = node_buts_curvecol;
2834                                 break;
2835
2836                         case TEX_NODE_CURVE_TIME:
2837                                 ntype->draw_buttons = node_buts_time;
2838                                 break;
2839
2840                         case TEX_NODE_TEXTURE:
2841                                 ntype->draw_buttons = node_buts_texture;
2842                                 break;
2843
2844                         case TEX_NODE_BRICKS:
2845                                 ntype->draw_buttons = node_texture_buts_bricks;
2846                                 break;
2847
2848                         case TEX_NODE_IMAGE:
2849                                 ntype->draw_buttons = node_texture_buts_image;
2850                                 ntype->draw_buttons_ex = node_texture_buts_image_ex;
2851                                 break;
2852
2853                         case TEX_NODE_OUTPUT:
2854                                 ntype->draw_buttons = node_texture_buts_output;
2855                                 break;
2856                 }
2857         }
2858 }
2859
2860 /* ******* init draw callbacks for all tree types, only called in usiblender.c, once ************* */
2861
2862 static void node_property_update_default(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2863 {
2864         bNodeTree *ntree = ptr->id.data;
2865         bNode *node = ptr->data;
2866         ED_node_tag_update_nodetree(bmain, ntree, node);
2867 }
2868
2869 static void node_socket_template_properties_update(bNodeType *ntype, bNodeSocketTemplate *stemp)
2870 {
2871         StructRNA *srna = ntype->ext.srna;
2872         PropertyRNA *prop = RNA_struct_type_find_property(srna, stemp->identifier);
2873         
2874         if (prop)
2875                 RNA_def_property_update_runtime(prop, node_property_update_default);
2876 }
2877
2878 static void node_template_properties_update(bNodeType *ntype)
2879 {
2880         bNodeSocketTemplate *stemp;
2881         
2882         if (ntype->inputs) {
2883                 for (stemp = ntype->inputs; stemp->type >= 0; ++stemp)
2884                         node_socket_template_properties_update(ntype, stemp);
2885         }
2886         if (ntype->outputs) {
2887                 for (stemp = ntype->outputs; stemp->type >= 0; ++stemp)
2888                         node_socket_template_properties_update(ntype, stemp);
2889         }
2890 }
2891
2892 static void node_socket_undefined_draw(bContext *UNUSED(C), uiLayout *layout, PointerRNA *UNUSED(ptr), PointerRNA *UNUSED(node_ptr),
2893                                        const char *UNUSED(text))
2894 {
2895         uiItemL(layout, IFACE_("Undefined Socket Type"), ICON_ERROR);
2896 }
2897
2898 static void node_socket_undefined_draw_color(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PointerRNA *UNUSED(node_ptr), float *r_color)
2899 {
2900         r_color[0] = 1.0f;
2901         r_color[1] = 0.0f;
2902         r_color[2] = 0.0f;
2903         r_color[3] = 1.0f;
2904 }
2905
2906 static void node_socket_undefined_interface_draw(bContext *UNUSED(C), uiLayout *layout, PointerRNA *UNUSED(ptr))
2907 {
2908         uiItemL(layout, IFACE_("Undefined Socket Type"), ICON_ERROR);
2909 }
2910
2911 static void node_socket_undefined_interface_draw_color(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), float *r_color)
2912 {
2913         r_color[0] = 1.0f;
2914         r_color[1] = 0.0f;
2915         r_color[2] = 0.0f;
2916         r_color[3] = 1.0f;
2917 }
2918
2919 void ED_node_init_butfuncs(void)
2920 {
2921         /* Fallback types for undefined tree, nodes, sockets
2922          * Defined in blenkernel, but not registered in type hashes.
2923          */
2924         /*extern bNodeTreeType NodeTreeTypeUndefined;*/
2925         extern bNodeType NodeTypeUndefined;
2926         extern bNodeSocketType NodeSocketTypeUndefined;
2927         
2928         /* default ui functions */
2929         NodeTypeUndefined.draw_nodetype = node_draw_default;
2930         NodeTypeUndefined.draw_nodetype_prepare = node_update_default;
2931         NodeTypeUndefined.select_area_func = node_select_area_default;
2932         NodeTypeUndefined.tweak_area_func = node_tweak_area_default;
2933         NodeTypeUndefined.draw_buttons = NULL;
2934         NodeTypeUndefined.draw_buttons_ex = NULL;
2935         NodeTypeUndefined.resize_area_func = node_resize_area_default;
2936         
2937         NodeSocketTypeUndefined.draw = node_socket_undefined_draw;
2938         NodeSocketTypeUndefined.draw_color = node_socket_undefined_draw_color;
2939         NodeSocketTypeUndefined.interface_draw = node_socket_undefined_interface_draw;
2940         NodeSocketTypeUndefined.interface_draw_color = node_socket_undefined_interface_draw_color;
2941         
2942         /* node type ui functions */
2943         NODE_TYPES_BEGIN(ntype)
2944                 /* default ui functions */
2945                 ntype->draw_nodetype = node_draw_default;
2946                 ntype->draw_nodetype_prepare = node_update_default;
2947                 ntype->select_area_func = node_select_area_default;
2948                 ntype->tweak_area_func = node_tweak_area_default;
2949                 ntype->draw_buttons = NULL;
2950                 ntype->draw_buttons_ex = NULL;
2951                 ntype->resize_area_func = node_resize_area_default;
2952                 
2953                 node_common_set_butfunc(ntype);
2954                 
2955                 node_composit_set_butfunc(ntype);
2956                 node_shader_set_butfunc(ntype);
2957                 node_texture_set_butfunc(ntype);
2958                 
2959                 /* define update callbacks for socket properties */
2960                 node_template_properties_update(ntype);
2961         NODE_TYPES_END
2962         
2963         /* tree type icons */
2964         ntreeType_Composite->ui_icon = ICON_RENDERLAYERS;
2965         ntreeType_Shader->ui_icon = ICON_MATERIAL;
2966         ntreeType_Texture->ui_icon = ICON_TEXTURE;
2967 }
2968
2969 void ED_init_custom_node_type(bNodeType *ntype)
2970 {
2971         /* default ui functions */
2972         ntype->draw_nodetype = node_draw_default;
2973         ntype->draw_nodetype_prepare = node_update_default;
2974         ntype->resize_area_func = node_resize_area_default;
2975         ntype->select_area_func = node_select_area_default;
2976         ntype->tweak_area_func = node_tweak_area_default;
2977 }
2978
2979 void ED_init_custom_node_socket_type(bNodeSocketType *stype)
2980 {
2981         /* default ui functions */
2982         stype->draw = node_socket_button_label;
2983 }
2984
2985 /* maps standard socket integer type to a color */
2986 static const float std_node_socket_colors[][4] = {
2987         {0.63, 0.63, 0.63, 1.0},    /* SOCK_FLOAT */
2988         {0.39, 0.39, 0.78, 1.0},    /* SOCK_VECTOR */
2989         {0.78, 0.78, 0.16, 1.0},    /* SOCK_RGBA */
2990         {0.39, 0.78, 0.39, 1.0},    /* SOCK_SHADER */
2991         {0.70, 0.65, 0.19, 1.0},    /* SOCK_BOOLEAN */
2992         {0.0, 0.0, 0.0, 1.0},       /*__SOCK_MESH (deprecated) */
2993         {0.06, 0.52, 0.15, 1.0},    /* SOCK_INT */
2994         {1.0, 1.0, 1.0, 1.0},       /* SOCK_STRING */
2995 };
2996
2997 /* common color callbacks for standard types */
2998 static void std_node_socket_draw_color(bContext *UNUSED(C), PointerRNA *ptr, PointerRNA *UNUSED(node_ptr), float *r_color)
2999 {
3000         bNodeSocket *sock = ptr->data;
3001         int type = sock->typeinfo->type;
3002         copy_v4_v4(r_color, std_node_socket_colors[type]);
3003 }
3004 static void std_node_socket_interface_draw_color(bContext *UNUSED(C), PointerRNA *ptr, float *r_color)
3005 {
3006         bNodeSocket *sock = ptr->data;
3007         int type = sock->typeinfo->type;
3008         copy_v4_v4(r_color, std_node_socket_colors[type]);
3009 }
3010
3011 /* draw function for file output node sockets, displays only sub-path and format, no value button */
3012 static void node_file_output_socket_draw(bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr)
3013 {
3014         bNodeTree *ntree = ptr->id.data;
3015         bNodeSocket *sock = ptr->data;
3016         uiLayout *row;
3017         PointerRNA inputptr, imfptr;
3018         int imtype;
3019         
3020         row = uiLayoutRow(layout, false);
3021         
3022         imfptr = RNA_pointer_get(node_ptr, "format");
3023         imtype = RNA_enum_get(&imfptr, "file_format");
3024
3025         if (imtype == R_IMF_IMTYPE_MULTILAYER) {
3026                 NodeImageMultiFileSocket *input = sock->storage;
3027                 RNA_pointer_create(&ntree->id, &RNA_NodeOutputFileSlotLayer, input, &inputptr);
3028                 
3029                 uiItemL(row, input->layer, ICON_NONE);
3030         }
3031         else {
3032                 NodeImageMultiFileSocket *input = sock->storage;
3033                 PropertyRNA *imtype_prop;
3034                 const char *imtype_name;
3035                 uiBlock *block;
3036                 RNA_pointer_create(&ntree->id, &RNA_NodeOutputFileSlotFile, input, &inputptr);
3037                 
3038                 uiItemL(row, input->path, ICON_NONE);
3039                 
3040                 if (!RNA_boolean_get(&inputptr, "use_node_format"))
3041                         imfptr = RNA_pointer_get(&inputptr, "format");
3042                 
3043                 imtype_prop = RNA_struct_find_property(&imfptr, "file_format");
3044                 RNA_property_enum_name((bContext *)C, &imfptr, imtype_prop,
3045                                        RNA_property_enum_get(&imfptr, imtype_prop), &imtype_name);
3046                 block = uiLayoutGetBlock(row);
3047                 UI_block_emboss_set(block, UI_EMBOSS_PULLDOWN);
3048                 uiItemL(row, imtype_name, ICON_NONE);
3049                 UI_block_emboss_set(block, UI_EMBOSS_NONE);
3050         }
3051 }
3052
3053 static void std_node_socket_draw(bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
3054 {
3055         bNode *node = node_ptr->data;
3056         bNodeSocket *sock = ptr->data;
3057         int type = sock->typeinfo->type;
3058         /*int subtype = sock->typeinfo->subtype;*/
3059         
3060         /* XXX not nice, eventually give this node its own socket type ... */
3061         if (node->type == CMP_NODE_OUTPUT_FILE) {
3062                 node_file_output_socket_draw(C, layout, ptr, node_ptr);
3063                 return;
3064         }
3065
3066         if ((sock->in_out == SOCK_OUT) || (sock->flag & SOCK_IN_USE) || (sock->flag & SOCK_HIDE_VALUE)) {
3067                 node_socket_button_label(C, layout, ptr, node_ptr, text);
3068                 return;
3069         }
3070         
3071         switch (type) {
3072                 case SOCK_FLOAT:
3073                 case SOCK_INT:
3074                 case SOCK_BOOLEAN:
3075                         uiItemR(layout, ptr, "default_value", 0, text, 0);
3076                         break;
3077                 case SOCK_VECTOR:
3078                         uiTemplateComponentMenu(layout, ptr, "default_value", text);
3079                         break;
3080                 case SOCK_RGBA:
3081                 {
3082                         uiLayout *row = uiLayoutRow(layout, false);
3083                         uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_LEFT);
3084                         /* draw the socket name right of the actual button */
3085                         uiItemR(row, ptr, "default_value", 0, "", 0);
3086                         uiItemL(row, text, 0);
3087                         break;
3088                 }
3089                 case SOCK_STRING:
3090                 {
3091                         uiLayout *row = uiLayoutRow(layout, true);
3092                         /* draw the socket name right of the actual button */
3093                         uiItemR(row, ptr, "default_value", 0, "", 0);
3094                         uiItemL(row, text, 0);
3095                         break;
3096                 }
3097                 default:
3098                         node_socket_button_label(C, layout, ptr, node_ptr, text);
3099                         break;
3100         }
3101 }
3102
3103 static void std_node_socket_interface_draw(bContext *UNUSED(C), uiLayout *layout, PointerRNA *ptr)
3104 {
3105         bNodeSocket *sock = ptr->data;
3106         int type = sock->typeinfo->type;
3107         /*int subtype = sock->typeinfo->subtype;*/
3108         
3109         switch (type) {
3110                 case SOCK_FLOAT:
3111                 {
3112                         uiLayout *row;
3113                         uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3114                         row = uiLayoutRow(layout, true);
3115                         uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3116                         uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3117                         break;
3118                 }
3119                 case SOCK_INT:
3120                 {
3121                         uiLayout *row;
3122                         uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3123                         row = uiLayoutRow(layout, true);
3124                         uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3125                         uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3126                         break;
3127                 }
3128                 case SOCK_BOOLEAN:
3129                 {
3130                         uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3131                         break;
3132                 }
3133                 case SOCK_VECTOR:
3134                 {
3135                         uiLayout *row;
3136                         uiItemR(layout, ptr, "default_value", UI_ITEM_R_EXPAND, NULL, 0);
3137                         row = uiLayoutRow(layout, true);
3138                         uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3139                         uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3140                         break;
3141                 }
3142                 case SOCK_RGBA:
3143                 {
3144                         uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3145                         break;
3146                 }
3147                 case SOCK_STRING:
3148                 {
3149                         uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3150                         break;
3151                 }
3152         }
3153 }
3154
3155 void ED_init_standard_node_socket_type(bNodeSocketType *stype)
3156 {
3157         stype->draw = std_node_socket_draw;
3158         stype->draw_color = std_node_socket_draw_color;
3159         stype->interface_draw = std_node_socket_interface_draw;
3160         stype->interface_draw_color = std_node_socket_interface_draw_color;
3161 }
3162
3163 static void node_socket_virtual_draw_color(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PointerRNA *UNUSED(node_ptr), float *r_color)
3164 {
3165         /* alpha = 0, empty circle */
3166         zero_v4(r_color);
3167 }
3168
3169 void ED_init_node_socket_type_virtual(bNodeSocketType *stype)
3170 {
3171         stype->draw = node_socket_button_label;
3172         stype->draw_color = node_socket_virtual_draw_color;
3173 }
3174
3175 /* ************** Generic drawing ************** */
3176
3177 void draw_nodespace_back_pix(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeInstanceKey parent_key)
3178 {
3179         bNodeInstanceKey active_viewer_key = (snode->nodetree ? snode->nodetree->active_viewer_key : NODE_INSTANCE_KEY_NONE);
3180         float shuffle[4] = {0.0f, 0.0f, 0.0f, 0.0f};
3181         Image *ima;
3182         void *lock;
3183         ImBuf *ibuf;
3184         
3185         if (!(snode->flag & SNODE_BACKDRAW) || !ED_node_is_compositor(snode))
3186                 return;
3187         
3188         if (parent_key.value != active_viewer_key.value)
3189                 return;
3190         
3191         ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
3192         ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
3193         if (ibuf) {
3194                 float x, y; 
3195
3196                 gpuPushProjectionMatrix();
3197                 gpuPushMatrix();
3198
3199                 /* somehow the offset has to be calculated inverse */
3200                 
3201                 glaDefine2DArea(&ar->winrct);
3202                 wmOrtho2_region_pixelspace(ar);
3203                 
3204                 x = (ar->winx - snode->zoom * ibuf->x) / 2 + snode->xof;
3205                 y = (ar->winy - snode->zoom * ibuf->y) / 2 + snode->yof;
3206                 
3207                 if (ibuf->rect || ibuf->rect_float) {
3208                         unsigned char *display_buffer = NULL;
3209                         void *cache_handle = NULL;
3210                         
3211                         if (snode->flag & (SNODE_SHOW_R | SNODE_SHOW_G | SNODE_SHOW_B | SNODE_SHOW_ALPHA)) {
3212                                 
3213                                 display_buffer = IMB_display_buffer_acquire_ctx(C, ibuf, &cache_handle);
3214
3215                                 if (snode->flag & SNODE_SHOW_R)
3216                                         shuffle[0] = 1.0f;
3217                                 else if (snode->flag & SNODE_SHOW_G)
3218                                         shuffle[1] = 1.0f;
3219                                 else if (snode->flag & SNODE_SHOW_B)
3220                                         shuffle[2] = 1.0f;
3221                                 else
3222                                         shuffle[3] = 1.0f;
3223
3224                                 IMMDrawPixelsTexState state = immDrawPixelsTexSetup(GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR);
3225                                 GPU_shader_uniform_vector(state.shader, GPU_shader_get_uniform(state.shader, "shuffle"), 4, 1, shuffle);
3226