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