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