use math functions rather then macros for bicubic interpolation.
[blender-staging.git] / source / blender / editors / space_node / node_draw.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) 2008 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  * Contributor(s): Nathan Letwory
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_node/node_draw.c
28  *  \ingroup spnode
29  *  \brief higher level node drawing for the node editor.
30  */
31
32 #include "DNA_lamp_types.h"
33 #include "DNA_node_types.h"
34 #include "DNA_material_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_space_types.h"
38 #include "DNA_texture_types.h"
39 #include "DNA_world_types.h"
40
41 #include "BLI_math.h"
42 #include "BLI_blenlib.h"
43
44 #include "BLF_translation.h"
45
46 #include "BKE_context.h"
47 #include "BKE_depsgraph.h"
48 #include "BKE_main.h"
49 #include "BKE_node.h"
50
51 #include "BLF_api.h"
52
53 #include "BIF_gl.h"
54 #include "BIF_glutil.h"
55
56 #include "WM_api.h"
57 #include "WM_types.h"
58
59 #include "ED_node.h"
60 #include "ED_gpencil.h"
61 #include "ED_screen.h"
62 #include "ED_space_api.h"
63
64 #include "UI_resources.h"
65 #include "UI_view2d.h"
66
67 #include "RNA_access.h"
68
69 #include "node_intern.h"  /* own include */
70 #include "COM_compositor.h"
71
72 /* XXX interface.h */
73 extern void ui_dropshadow(const rctf *rct, float radius, float aspect, float alpha, int select);
74
75 void ED_node_tree_update(const bContext *C)
76 {
77         SpaceNode *snode = CTX_wm_space_node(C);
78         if (snode) {
79                 snode_set_context(C);
80
81                 if (snode->nodetree && snode->nodetree->id.us == 0) {
82                         snode->nodetree->id.us = 1;
83                 }
84         }
85 }
86
87 /* id is supposed to contain a node tree */
88 static bNodeTree *node_tree_from_ID(ID *id)
89 {
90         if (id) {
91                 short idtype = GS(id->name);
92         
93                 switch (idtype) {
94                 case ID_NT:
95                         return (bNodeTree *)id;
96                 case ID_MA:
97                         return ((Material *)id)->nodetree;
98                 case ID_LA:
99                         return ((Lamp *)id)->nodetree;
100                 case ID_WO:
101                         return ((World *)id)->nodetree;
102                 case ID_SCE:
103                         return ((Scene *)id)->nodetree;
104                 case ID_TE:
105                         return ((Tex *)id)->nodetree;
106                 }
107         }
108         
109         return NULL;
110 }
111
112 void ED_node_tag_update_id(ID *id)
113 {
114         bNodeTree *ntree = node_tree_from_ID(id);
115         if (id == NULL || ntree == NULL)
116                 return;
117         
118         if (ntree->type == NTREE_SHADER) {
119                 DAG_id_tag_update(id, 0);
120                 
121                 if (GS(id->name) == ID_MA)
122                         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, id);
123                 else if (GS(id->name) == ID_LA)
124                         WM_main_add_notifier(NC_LAMP | ND_LIGHTING_DRAW, id);
125                 else if (GS(id->name) == ID_WO)
126                         WM_main_add_notifier(NC_WORLD | ND_WORLD_DRAW, id);
127         }
128         else if (ntree->type == NTREE_COMPOSIT) {
129                 WM_main_add_notifier(NC_SCENE | ND_NODES, id);
130         }
131         else if (ntree->type == NTREE_TEXTURE) {
132                 DAG_id_tag_update(id, 0);
133                 WM_main_add_notifier(NC_TEXTURE | ND_NODES, id);
134         }
135 }
136
137 static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup)
138 {
139         bNode *node;
140         
141         if (ntree == lookup)
142                 return 1;
143         
144         for (node = ntree->nodes.first; node; node = node->next)
145                 if (node->type == NODE_GROUP && node->id)
146                         if (has_nodetree((bNodeTree *)node->id, lookup))
147                                 return 1;
148         
149         return 0;
150 }
151
152 void ED_node_tag_update_nodetree(Main *bmain, bNodeTree *ntree)
153 {
154         if (!ntree)
155                 return;
156         
157         /* look through all datablocks, to support groups */
158         FOREACH_NODETREE(bmain, tntree, id) {
159                 /* check if nodetree uses the group */
160                 if (has_nodetree(tntree, ntree))
161                         ED_node_tag_update_id(id);
162         } FOREACH_NODETREE_END
163         
164         if (ntree->type == NTREE_TEXTURE)
165                 ntreeTexCheckCyclics(ntree);
166 }
167
168 static int compare_nodes(bNode *a, bNode *b)
169 {
170         bNode *parent;
171         /* These tell if either the node or any of the parent nodes is selected.
172          * A selected parent means an unselected node is also in foreground!
173          */
174         int a_select = (a->flag & NODE_SELECT), b_select = (b->flag & NODE_SELECT);
175         int a_active = (a->flag & NODE_ACTIVE), b_active = (b->flag & NODE_ACTIVE);
176         
177         /* if one is an ancestor of the other */
178         /* XXX there might be a better sorting algorithm for stable topological sort, this is O(n^2) worst case */
179         for (parent = a->parent; parent; parent = parent->parent) {
180                 /* if b is an ancestor, it is always behind a */
181                 if (parent == b)
182                         return 1;
183                 /* any selected ancestor moves the node forward */
184                 if (parent->flag & NODE_ACTIVE)
185                         a_active = 1;
186                 if (parent->flag & NODE_SELECT)
187                         a_select = 1;
188         }
189         for (parent = b->parent; parent; parent = parent->parent) {
190                 /* if a is an ancestor, it is always behind b */
191                 if (parent == a)
192                         return 0;
193                 /* any selected ancestor moves the node forward */
194                 if (parent->flag & NODE_ACTIVE)
195                         b_active = 1;
196                 if (parent->flag & NODE_SELECT)
197                         b_select = 1;
198         }
199
200         /* if one of the nodes is in the background and the other not */
201         if ((a->flag & NODE_BACKGROUND) && !(b->flag & NODE_BACKGROUND))
202                 return 0;
203         else if (!(a->flag & NODE_BACKGROUND) && (b->flag & NODE_BACKGROUND))
204                 return 1;
205         
206         /* if one has a higher selection state (active > selected > nothing) */
207         if (!b_active && a_active)
208                 return 1;
209         else if (!b_select && (a_active || a_select))
210                 return 1;
211         
212         return 0;
213 }
214
215 /* Sorts nodes by selection: unselected nodes first, then selected,
216  * then the active node at the very end. Relative order is kept intact!
217  */
218 void ED_node_sort(bNodeTree *ntree)
219 {
220         /* merge sort is the algorithm of choice here */
221         bNode *first_a, *first_b, *node_a, *node_b, *tmp;
222         int totnodes = BLI_countlist(&ntree->nodes);
223         int k, a, b;
224         
225         k = 1;
226         while (k < totnodes) {
227                 first_a = first_b = ntree->nodes.first;
228                 
229                 do {
230                         /* setup first_b pointer */
231                         for (b = 0; b < k && first_b; ++b) {
232                                 first_b = first_b->next;
233                         }
234                         /* all batches merged? */
235                         if (first_b == NULL)
236                                 break;
237                         
238                         /* merge batches */
239                         node_a = first_a;
240                         node_b = first_b;
241                         a = b = 0;
242                         while (a < k && b < k && node_b) {
243                                 if (compare_nodes(node_a, node_b) == 0) {
244                                         node_a = node_a->next;
245                                         a++;
246                                 }
247                                 else {
248                                         tmp = node_b;
249                                         node_b = node_b->next;
250                                         b++;
251                                         BLI_remlink(&ntree->nodes, tmp);
252                                         BLI_insertlinkbefore(&ntree->nodes, node_a, tmp);
253                                 }
254                         }
255
256                         /* setup first pointers for next batch */
257                         first_b = node_b;
258                         for (; b < k; ++b) {
259                                 /* all nodes sorted? */
260                                 if (first_b == NULL)
261                                         break;
262                                 first_b = first_b->next;
263                         }
264                         first_a = first_b;
265                 } while (first_b);
266                 
267                 k = k << 1;
268         }
269 }
270
271
272 static void do_node_internal_buttons(bContext *C, void *UNUSED(node_v), int event)
273 {
274         if (event == B_NODE_EXEC) {
275                 SpaceNode *snode = CTX_wm_space_node(C);
276                 if (snode && snode->id)
277                         ED_node_tag_update_id(snode->id);
278         }
279 }
280
281 static void node_uiblocks_init(const bContext *C, bNodeTree *ntree)
282 {
283         bNode *node;
284         char uiblockstr[32];
285         
286         /* add node uiBlocks in drawing order - prevents events going to overlapping nodes */
287         
288         for (node = ntree->nodes.first; node; node = node->next) {
289                 /* ui block */
290                 BLI_snprintf(uiblockstr, sizeof(uiblockstr), "node buttons %p", (void *)node);
291                 node->block = uiBeginBlock(C, CTX_wm_region(C), uiblockstr, UI_EMBOSS);
292                 uiBlockSetHandleFunc(node->block, do_node_internal_buttons, node);
293
294                 /* this cancels events for background nodes */
295                 uiBlockSetFlag(node->block, UI_BLOCK_CLIP_EVENTS);
296         }
297 }
298
299 void node_to_view(struct bNode *node, float x, float y, float *rx, float *ry)
300 {
301         nodeToView(node, x, y, rx, ry);
302         *rx *= UI_DPI_FAC;
303         *ry *= UI_DPI_FAC;
304 }
305
306 void node_from_view(struct bNode *node, float x, float y, float *rx, float *ry)
307 {
308         x /= UI_DPI_FAC;
309         y /= UI_DPI_FAC;
310         nodeFromView(node, x, y, rx, ry);
311 }
312
313
314 /* based on settings in node, sets drawing rect info. each redraw! */
315 static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node)
316 {
317         uiLayout *layout, *row;
318         PointerRNA nodeptr, sockptr;
319         bNodeSocket *nsock;
320         float locx, locy;
321         float dy;
322         int buty;
323         
324         RNA_pointer_create(&ntree->id, &RNA_Node, node, &nodeptr);
325         
326         /* get "global" coords */
327         node_to_view(node, 0.0f, 0.0f, &locx, &locy);
328         dy = locy;
329         
330         /* header */
331         dy -= NODE_DY;
332         
333         /* little bit space in top */
334         if (node->outputs.first)
335                 dy -= NODE_DYS / 2;
336         
337         /* output sockets */
338         for (nsock = node->outputs.first; nsock; nsock = nsock->next) {
339                 if (nodeSocketIsHidden(nsock))
340                         continue;
341                 
342                 RNA_pointer_create(&ntree->id, &RNA_NodeSocket, nsock, &sockptr);
343                 
344                 layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL,
345                                        locx + NODE_DYS, dy, NODE_WIDTH(node) - NODE_DY, NODE_DY, UI_GetStyle());
346                 /* context pointers for current node and socket */
347                 uiLayoutSetContextPointer(layout, "node", &nodeptr);
348                 uiLayoutSetContextPointer(layout, "socket", &sockptr);
349                 
350                 /* align output buttons to the right */
351                 row = uiLayoutRow(layout, 1);
352                 uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_RIGHT);
353                 
354                 node->typeinfo->drawoutputfunc((bContext *)C, row, &sockptr, &nodeptr);
355                 
356                 uiBlockEndAlign(node->block);
357                 uiBlockLayoutResolve(node->block, NULL, &buty);
358                 
359                 /* ensure minimum socket height in case layout is empty */
360                 buty = min_ii(buty, dy - NODE_DY);
361                 
362                 nsock->locx = locx + NODE_WIDTH(node);
363                 /* place the socket circle in the middle of the layout */
364                 nsock->locy = 0.5f * (dy + buty);
365                 
366                 dy = buty;
367                 if (nsock->next)
368                         dy -= NODE_SOCKDY;
369         }
370
371         node->prvr.xmin = locx + NODE_DYS;
372         node->prvr.xmax = locx + NODE_WIDTH(node) - NODE_DYS;
373
374         /* preview rect? */
375         if (node->flag & NODE_PREVIEW) {
376                 float aspect = 1.0f;
377                 
378                 if (node->preview_xsize && node->preview_ysize) 
379                         aspect = (float)node->preview_ysize / (float)node->preview_xsize;
380                 
381                 dy -= NODE_DYS / 2;
382                 node->prvr.ymax = dy;
383                 
384                 if (aspect <= 1.0f)
385                         node->prvr.ymin = dy - aspect * (NODE_WIDTH(node) - NODE_DY);
386                 else {
387                         /* width correction of image */
388                         /* XXX huh? (ton) */
389                         float dx = (NODE_WIDTH(node) - NODE_DYS) - (NODE_WIDTH(node) - NODE_DYS) / aspect;
390                         
391                         node->prvr.ymin = dy - (NODE_WIDTH(node) - NODE_DY);
392                         
393                         node->prvr.xmin += 0.5f * dx;
394                         node->prvr.xmax -= 0.5f * dx;
395                 }
396                 
397                 dy = node->prvr.ymin - NODE_DYS / 2;
398                 
399                 /* make sure that maximums are bigger or equal to minimums */
400                 if (node->prvr.xmax < node->prvr.xmin) SWAP(float, node->prvr.xmax, node->prvr.xmin);
401                 if (node->prvr.ymax < node->prvr.ymin) SWAP(float, node->prvr.ymax, node->prvr.ymin);
402         }
403
404         /* buttons rect? */
405         /* TODO: NODE_OPTION shall be cleaned up */
406         if (/*(node->flag & NODE_OPTIONS) && */node->typeinfo->uifunc) {
407                 dy -= NODE_DYS / 2;
408
409                 /* set this for uifunc() that don't use layout engine yet */
410                 node->butr.xmin = 0;
411                 node->butr.xmax = NODE_WIDTH(node) - 2 * NODE_DYS;
412                 node->butr.ymin = 0;
413                 node->butr.ymax = 0;
414                 
415                         
416                 layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL,
417                                        locx + NODE_DYS, dy, node->butr.xmax, 0, UI_GetStyle());
418                 uiLayoutSetContextPointer(layout, "node", &nodeptr);
419                 
420                 node->typeinfo->uifunc(layout, (bContext *)C, &nodeptr);
421                 
422                 uiBlockEndAlign(node->block);
423                 uiBlockLayoutResolve(node->block, NULL, &buty);
424                         
425                 dy = buty - NODE_DYS / 2;
426         }
427
428         /* input sockets */
429         for (nsock = node->inputs.first; nsock; nsock = nsock->next) {
430                 if (nodeSocketIsHidden(nsock))
431                         continue;
432                 
433                 RNA_pointer_create(&ntree->id, &RNA_NodeSocket, nsock, &sockptr);
434                 
435                 layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL,
436                                        locx + NODE_DYS, dy, NODE_WIDTH(node) - NODE_DY, NODE_DY, UI_GetStyle());
437                 /* context pointers for current node and socket */
438                 uiLayoutSetContextPointer(layout, "node", &nodeptr);
439                 uiLayoutSetContextPointer(layout, "socket", &sockptr);
440                 
441                 node->typeinfo->drawinputfunc((bContext *)C, layout, &sockptr, &nodeptr);
442                 
443                 uiBlockEndAlign(node->block);
444                 uiBlockLayoutResolve(node->block, NULL, &buty);
445                 
446                 /* ensure minimum socket height in case layout is empty */
447                 buty = min_ii(buty, dy - NODE_DY);
448                 
449                 nsock->locx = locx;
450                 /* place the socket circle in the middle of the layout */
451                 nsock->locy = 0.5f * (dy + buty);
452                 
453                 dy = buty;
454                 if (nsock->next)
455                         dy -= NODE_SOCKDY;
456         }
457         
458         /* little bit space in end */
459         if (node->inputs.first || (node->flag & (NODE_OPTIONS | NODE_PREVIEW)) == 0)
460                 dy -= NODE_DYS / 2;
461
462         node->totr.xmin = locx;
463         node->totr.xmax = locx + NODE_WIDTH(node);
464         node->totr.ymax = locy;
465         node->totr.ymin = min_ff(dy, locy - 2 * NODE_DY);
466         
467         /* Set the block bounds to clip mouse events from underlying nodes.
468          * Add a margin for sockets on each side.
469          */
470         uiExplicitBoundsBlock(node->block,
471                               node->totr.xmin - NODE_SOCKSIZE,
472                               node->totr.ymin,
473                               node->totr.xmax + NODE_SOCKSIZE,
474                               node->totr.ymax);
475 }
476
477 /* based on settings in node, sets drawing rect info. each redraw! */
478 static void node_update_hidden(bNode *node)
479 {
480         bNodeSocket *nsock;
481         float locx, locy;
482         float rad, drad, hiddenrad = HIDDEN_RAD;
483         int totin = 0, totout = 0, tot;
484         
485         /* get "global" coords */
486         node_to_view(node, 0.0f, 0.0f, &locx, &locy);
487
488         /* calculate minimal radius */
489         for (nsock = node->inputs.first; nsock; nsock = nsock->next)
490                 if (!nodeSocketIsHidden(nsock))
491                         totin++;
492         for (nsock = node->outputs.first; nsock; nsock = nsock->next)
493                 if (!nodeSocketIsHidden(nsock))
494                         totout++;
495         
496         tot = MAX2(totin, totout);
497         if (tot > 4) {
498                 hiddenrad += 5.0f * (float)(tot - 4);
499         }
500         
501         node->totr.xmin = locx;
502         node->totr.xmax = locx + 3 * hiddenrad + node->miniwidth;
503         node->totr.ymax = locy + (hiddenrad - 0.5f * NODE_DY);
504         node->totr.ymin = node->totr.ymax - 2 * hiddenrad;
505         
506         /* output sockets */
507         rad = drad = (float)M_PI / (1.0f + (float)totout);
508         
509         for (nsock = node->outputs.first; nsock; nsock = nsock->next) {
510                 if (!nodeSocketIsHidden(nsock)) {
511                         nsock->locx = node->totr.xmax - hiddenrad + sinf(rad) * hiddenrad;
512                         nsock->locy = node->totr.ymin + hiddenrad + cosf(rad) * hiddenrad;
513                         rad += drad;
514                 }
515         }
516         
517         /* input sockets */
518         rad = drad = -(float)M_PI / (1.0f + (float)totin);
519         
520         for (nsock = node->inputs.first; nsock; nsock = nsock->next) {
521                 if (!nodeSocketIsHidden(nsock)) {
522                         nsock->locx = node->totr.xmin + hiddenrad + sinf(rad) * hiddenrad;
523                         nsock->locy = node->totr.ymin + hiddenrad + cosf(rad) * hiddenrad;
524                         rad += drad;
525                 }
526         }
527
528         /* Set the block bounds to clip mouse events from underlying nodes.
529          * Add a margin for sockets on each side.
530          */
531         uiExplicitBoundsBlock(node->block,
532                               node->totr.xmin - NODE_SOCKSIZE,
533                               node->totr.ymin,
534                               node->totr.xmax + NODE_SOCKSIZE,
535                               node->totr.ymax);
536 }
537
538 void node_update_default(const bContext *C, bNodeTree *ntree, bNode *node)
539 {
540         if (node->flag & NODE_HIDDEN)
541                 node_update_hidden(node);
542         else
543                 node_update_basis(C, ntree, node);
544 }
545
546 int node_select_area_default(bNode *node, int x, int y)
547 {
548         return BLI_rctf_isect_pt(&node->totr, x, y);
549 }
550
551 int node_tweak_area_default(bNode *node, int x, int y)
552 {
553         return BLI_rctf_isect_pt(&node->totr, x, y);
554 }
555
556 int node_get_colorid(bNode *node)
557 {
558         switch (node->typeinfo->nclass) {
559                 case NODE_CLASS_INPUT:      return TH_NODE_IN_OUT;
560                 case NODE_CLASS_OUTPUT:     return (node->flag & NODE_DO_OUTPUT) ? TH_NODE_IN_OUT : TH_NODE;
561                 case NODE_CLASS_CONVERTOR:  return TH_NODE_CONVERTOR;
562                 case NODE_CLASS_OP_COLOR:
563                 case NODE_CLASS_OP_VECTOR:
564                 case NODE_CLASS_OP_FILTER:  return TH_NODE_OPERATOR;
565                 case NODE_CLASS_GROUP:      return TH_NODE_GROUP;
566                 case NODE_CLASS_INTERFACE:  return TH_NODE_INTERFACE;
567                 case NODE_CLASS_MATTE:      return TH_NODE_MATTE;
568                 case NODE_CLASS_DISTORT:    return TH_NODE_DISTORT;
569                 default:                    return TH_NODE;
570         }
571 }
572
573 /* note: in cmp_util.c is similar code, for node_compo_pass_on()
574  *       the same goes for shader and texture nodes. */
575 /* note: in node_edit.c is similar code, for untangle node */
576 static void node_draw_mute_line(View2D *v2d, SpaceNode *snode, bNode *node)
577 {
578         bNodeLink *link;
579
580         glEnable(GL_BLEND);
581         glEnable(GL_LINE_SMOOTH);
582
583         for (link = node->internal_links.first; link; link = link->next)
584                 node_draw_link_bezier(v2d, snode, link, TH_REDALERT, 0, TH_WIRE, 0, TH_WIRE);
585
586         glDisable(GL_BLEND);
587         glDisable(GL_LINE_SMOOTH);
588 }
589
590 /* this might have some more generic use */
591 static void node_circle_draw(float x, float y, float size, float *col, int highlight)
592 {
593         /* 16 values of sin function */
594         static float si[16] = {
595                 0.00000000f, 0.39435585f, 0.72479278f, 0.93775213f,
596                 0.99871650f, 0.89780453f, 0.65137248f, 0.29936312f,
597                 -0.10116832f, -0.48530196f, -0.79077573f, -0.96807711f,
598                 -0.98846832f, -0.84864425f, -0.57126821f, -0.20129852f
599         };
600         /* 16 values of cos function */
601         static float co[16] = {
602                 1.00000000f, 0.91895781f, 0.68896691f, 0.34730525f,
603                 -0.05064916f, -0.44039415f, -0.75875812f, -0.95413925f,
604                 -0.99486932f, -0.87434661f, -0.61210598f, -0.25065253f,
605                 0.15142777f, 0.52896401f, 0.82076344f, 0.97952994f,
606         };
607         int a;
608         
609         glColor4fv(col);
610         
611         glEnable(GL_BLEND);
612         glBegin(GL_POLYGON);
613         for (a = 0; a < 16; a++)
614                 glVertex2f(x + size * si[a], y + size * co[a]);
615         glEnd();
616         glDisable(GL_BLEND);
617         
618         if (highlight) {
619                 UI_ThemeColor(TH_TEXT_HI);
620                 glLineWidth(1.5f);
621         }
622         else {
623                 glColor4ub(0, 0, 0, 150);
624         }
625         glEnable(GL_BLEND);
626         glEnable(GL_LINE_SMOOTH);
627         glBegin(GL_LINE_LOOP);
628         for (a = 0; a < 16; a++)
629                 glVertex2f(x + size * si[a], y + size * co[a]);
630         glEnd();
631         glDisable(GL_LINE_SMOOTH);
632         glDisable(GL_BLEND);
633         glLineWidth(1.0f);
634 }
635
636 void node_socket_circle_draw(const bContext *C, bNodeTree *ntree, bNode *node, bNodeSocket *sock, float size, int highlight)
637 {
638         PointerRNA ptr, node_ptr;
639         float color[4];
640         
641         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
642         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
643         sock->typeinfo->draw_color((bContext *)C, &ptr, &node_ptr, color);
644         node_circle_draw(sock->locx, sock->locy, size, color, highlight);
645 }
646
647 /* **************  Socket callbacks *********** */
648
649 static void node_draw_preview_background(float tile, rctf *rect)
650 {
651         float x, y;
652         
653         /* draw checkerboard backdrop to show alpha */
654         glColor3ub(120, 120, 120);
655         glRectf(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
656         glColor3ub(160, 160, 160);
657         
658         for (y = rect->ymin; y < rect->ymax; y += tile * 2) {
659                 for (x = rect->xmin; x < rect->xmax; x += tile * 2) {
660                         float tilex = tile, tiley = tile;
661
662                         if (x + tile > rect->xmax)
663                                 tilex = rect->xmax - x;
664                         if (y + tile > rect->ymax)
665                                 tiley = rect->ymax - y;
666
667                         glRectf(x, y, x + tilex, y + tiley);
668                 }
669         }
670         for (y = rect->ymin + tile; y < rect->ymax; y += tile * 2) {
671                 for (x = rect->xmin + tile; x < rect->xmax; x += tile * 2) {
672                         float tilex = tile, tiley = tile;
673
674                         if (x + tile > rect->xmax)
675                                 tilex = rect->xmax - x;
676                         if (y + tile > rect->ymax)
677                                 tiley = rect->ymax - y;
678
679                         glRectf(x, y, x + tilex, y + tiley);
680                 }
681         }
682 }
683
684 /* not a callback */
685 static void node_draw_preview(bNodePreview *preview, rctf *prv)
686 {
687         float xrect = BLI_rctf_size_x(prv);
688         float yrect = BLI_rctf_size_y(prv);
689         float xscale = xrect / ((float)preview->xsize);
690         float yscale = yrect / ((float)preview->ysize);
691         float scale;
692         rctf draw_rect;
693         
694         /* uniform scale and offset */
695         draw_rect = *prv;
696         if (xscale < yscale) {
697                 float offset = 0.5f * (yrect - ((float)preview->ysize) * xscale);
698                 draw_rect.ymin += offset;
699                 draw_rect.ymax -= offset;
700                 scale = xscale;
701         }
702         else {
703                 float offset = 0.5f * (xrect - ((float)preview->xsize) * yscale);
704                 draw_rect.xmin += offset;
705                 draw_rect.xmax -= offset;
706                 scale = yscale;
707         }
708         
709         node_draw_preview_background(BLI_rctf_size_x(prv) / 10.0f, &draw_rect);
710         
711         glEnable(GL_BLEND);
712         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  /* premul graphics */
713         
714         glColor4f(1.0, 1.0, 1.0, 1.0);
715         glPixelZoom(scale, scale);
716         glaDrawPixelsTex(draw_rect.xmin, draw_rect.ymin, preview->xsize, preview->ysize, GL_RGBA, GL_UNSIGNED_BYTE, GL_LINEAR, preview->rect);
717         glPixelZoom(1.0f, 1.0f);
718         
719         glDisable(GL_BLEND);
720
721         UI_ThemeColorShadeAlpha(TH_BACK, -15, +100);
722         fdrawbox(draw_rect.xmin, draw_rect.ymin, draw_rect.xmax, draw_rect.ymax);
723 }
724
725 /* common handle function for operator buttons that need to select the node first */
726 static void node_toggle_button_cb(struct bContext *C, void *node_argv, void *op_argv)
727 {
728         bNode *node = (bNode *)node_argv;
729         const char *opname = (const char *)op_argv;
730         
731         /* select & activate only the button's node */
732         node_select_single(C, node);
733         
734         WM_operator_name_call(C, opname, WM_OP_INVOKE_DEFAULT, NULL);
735 }
736
737 void node_draw_shadow(SpaceNode *snode, bNode *node, float radius, float alpha)
738 {
739         rctf *rct = &node->totr;
740         
741         uiSetRoundBox(UI_CNR_ALL);
742         if (node->parent == NULL)
743                 ui_dropshadow(rct, radius, snode->aspect, alpha, node->flag & SELECT);
744         else {
745                 const float margin = 3.0f;
746                 
747                 glColor4f(0.0f, 0.0f, 0.0f, 0.33f);
748                 glEnable(GL_BLEND);
749                 uiRoundBox(rct->xmin - margin, rct->ymin - margin,
750                            rct->xmax + margin, rct->ymax + margin, radius + margin);
751                 glDisable(GL_BLEND);
752         }
753 }
754
755 static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key)
756 {
757         bNodeInstanceHash *previews = CTX_data_pointer_get(C, "node_previews").data;
758         bNodeSocket *sock;
759         rctf *rct = &node->totr;
760         float iconofs;
761         /* float socket_size = NODE_SOCKSIZE*U.dpi/72; */ /* UNUSED */
762         float iconbutw = 0.8f * UI_UNIT_X;
763         int color_id = node_get_colorid(node);
764         char showname[128]; /* 128 used below */
765         View2D *v2d = &ar->v2d;
766         
767         /* XXX hack: copy values from linked ID data where displayed as sockets */
768         if (node->block)
769                 nodeSynchronizeID(node, false);
770         
771         /* skip if out of view */
772         if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == FALSE) {
773                 uiEndBlock(C, node->block);
774                 node->block = NULL;
775                 return;
776         }
777         
778         /* shadow */
779         node_draw_shadow(snode, node, BASIS_RAD, 1.0f);
780         
781         /* header uses color from backdrop, but we make it opaqie */
782         if (color_id == TH_NODE) {
783                 float col[3];
784                 UI_GetThemeColorShade3fv(color_id, -20, col);
785                 glColor4f(col[0], col[1], col[2], 1.0f);
786         }
787         else
788                 UI_ThemeColor(color_id);
789         
790         if (node->flag & NODE_MUTED)
791                 UI_ThemeColorBlend(color_id, TH_REDALERT, 0.5f);
792         
793
794 #ifdef WITH_COMPOSITOR
795         if (ntree->type == NTREE_COMPOSIT && (snode->flag & SNODE_SHOW_HIGHLIGHT)) {
796                 if (COM_isHighlightedbNode(node)) {
797                         UI_ThemeColorBlend(color_id, TH_ACTIVE, 0.5f);
798                 }
799         }
800 #endif
801
802         uiSetRoundBox(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
803         uiRoundBox(rct->xmin, rct->ymax - NODE_DY, rct->xmax, rct->ymax, BASIS_RAD);
804         
805         /* show/hide icons */
806         iconofs = rct->xmax - 0.35f * U.widget_unit;
807         
808         /* preview */
809         if (node->typeinfo->flag & NODE_PREVIEW) {
810                 uiBut *but;
811                 iconofs -= iconbutw;
812                 uiBlockSetEmboss(node->block, UI_EMBOSSN);
813                 but = uiDefIconBut(node->block, TOGBUT, B_REDR, ICON_MATERIAL,
814                                    iconofs, rct->ymax - NODE_DY, iconbutw, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
815                 uiButSetFunc(but, node_toggle_button_cb, node, (void *)"NODE_OT_preview_toggle");
816                 /* XXX this does not work when node is activated and the operator called right afterwards,
817                  * since active ID is not updated yet (needs to process the notifier).
818                  * This can only work as visual indicator!
819                  */
820 //              if (!(node->flag & (NODE_ACTIVE_ID|NODE_DO_OUTPUT)))
821 //                      uiButSetFlag(but, UI_BUT_DISABLED);
822                 uiBlockSetEmboss(node->block, UI_EMBOSS);
823         }
824         /* group edit */
825         if (node->type == NODE_GROUP) {
826                 uiBut *but;
827                 iconofs -= iconbutw;
828                 uiBlockSetEmboss(node->block, UI_EMBOSSN);
829                 but = uiDefIconBut(node->block, TOGBUT, B_REDR, ICON_NODETREE,
830                                    iconofs, rct->ymax - NODE_DY, iconbutw, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
831                 uiButSetFunc(but, node_toggle_button_cb, node, (void *)"NODE_OT_group_edit");
832                 uiBlockSetEmboss(node->block, UI_EMBOSS);
833         }
834         
835         /* title */
836         if (node->flag & SELECT) 
837                 UI_ThemeColor(TH_SELECT);
838         else
839                 UI_ThemeColorBlendShade(TH_TEXT, color_id, 0.4f, 10);
840         
841         /* open/close entirely? */
842         {
843                 uiBut *but;
844                 int but_size = UI_UNIT_X * 0.6f;
845                 /* XXX button uses a custom triangle draw below, so make it invisible without icon */
846                 uiBlockSetEmboss(node->block, UI_EMBOSSN);
847                 but = uiDefBut(node->block, TOGBUT, B_REDR, "",
848                                rct->xmin + 0.5f * U.widget_unit - but_size / 2, rct->ymax - NODE_DY / 2.0f - but_size / 2,
849                                but_size, but_size, NULL, 0, 0, 0, 0, "");
850                 uiButSetFunc(but, node_toggle_button_cb, node, (void *)"NODE_OT_hide_toggle");
851                 uiBlockSetEmboss(node->block, UI_EMBOSS);
852                 
853                 /* custom draw function for this button */
854                 UI_DrawTriIcon(rct->xmin + 0.5f * U.widget_unit, rct->ymax - NODE_DY / 2.0f, 'v');
855         }
856         
857         /* this isn't doing anything for the label, so commenting out */
858 #if 0
859         if (node->flag & SELECT) 
860                 UI_ThemeColor(TH_TEXT_HI);
861         else
862                 UI_ThemeColor(TH_TEXT);
863 #endif
864         
865         BLI_strncpy(showname, nodeLabel(node), sizeof(showname));
866         
867         //if (node->flag & NODE_MUTED)
868         //      BLI_snprintf(showname, sizeof(showname), "[%s]", showname); /* XXX - don't print into self! */
869         
870         uiDefBut(node->block, LABEL, 0, showname,
871                  (int)(rct->xmin + (NODE_MARGIN_X)), (int)(rct->ymax - NODE_DY),
872                  (short)(iconofs - rct->xmin - 18.0f), (short)NODE_DY,
873                  NULL, 0, 0, 0, 0, "");
874
875         /* body */
876         if (!nodeIsRegistered(node))
877                 UI_ThemeColor4(TH_REDALERT);    /* use warning color to indicate undefined types */
878         else if (node->flag & NODE_CUSTOM_COLOR)
879                 glColor3fv(node->color);
880         else
881                 UI_ThemeColor4(TH_NODE);
882         glEnable(GL_BLEND);
883         uiSetRoundBox(UI_CNR_BOTTOM_LEFT | UI_CNR_BOTTOM_RIGHT);
884         uiRoundBox(rct->xmin, rct->ymin, rct->xmax, rct->ymax - NODE_DY, BASIS_RAD);
885         glDisable(GL_BLEND);
886
887         /* outline active and selected emphasis */
888         if (node->flag & SELECT) {
889                 
890                 glEnable(GL_BLEND);
891                 glEnable(GL_LINE_SMOOTH);
892                 
893                 if (node->flag & NODE_ACTIVE)
894                         UI_ThemeColorShadeAlpha(TH_ACTIVE, 0, -40);
895                 else
896                         UI_ThemeColorShadeAlpha(TH_SELECT, 0, -40);
897                 
898                 uiSetRoundBox(UI_CNR_ALL);
899                 uiDrawBox(GL_LINE_LOOP, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD);
900                 
901                 glDisable(GL_LINE_SMOOTH);
902                 glDisable(GL_BLEND);
903         }
904         
905         /* disable lines */
906         if (node->flag & NODE_MUTED)
907                 node_draw_mute_line(v2d, snode, node);
908
909         
910         /* socket inputs, buttons */
911         for (sock = node->inputs.first; sock; sock = sock->next) {
912                 if (nodeSocketIsHidden(sock))
913                         continue;
914                 
915                 node_socket_circle_draw(C, ntree, node, sock, NODE_SOCKSIZE, sock->flag & SELECT);
916         }
917         
918         /* socket outputs */
919         for (sock = node->outputs.first; sock; sock = sock->next) {
920                 if (nodeSocketIsHidden(sock))
921                         continue;
922                 
923                 node_socket_circle_draw(C, ntree, node, sock, NODE_SOCKSIZE, sock->flag & SELECT);
924         }
925         
926         /* preview */
927         if (node->flag & NODE_PREVIEW) {
928                 bNodePreview *preview = previews ? BKE_node_instance_hash_lookup(previews, key) : NULL;
929                 if (preview && preview->rect && !BLI_rctf_is_empty(&node->prvr))
930                         node_draw_preview(preview, &node->prvr);
931         }
932         
933         UI_ThemeClearColor(color_id);
934                 
935         uiEndBlock(C, node->block);
936         uiDrawBlock(C, node->block);
937         node->block = NULL;
938 }
939
940 static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey UNUSED(key))
941 {
942         bNodeSocket *sock;
943         rctf *rct = &node->totr;
944         float dx, centy = BLI_rctf_cent_y(rct);
945         float hiddenrad = BLI_rctf_size_y(rct) / 2.0f;
946         float socket_size = NODE_SOCKSIZE;
947         int color_id = node_get_colorid(node);
948         char showname[128]; /* 128 is used below */
949         
950         /* shadow */
951         node_draw_shadow(snode, node, hiddenrad, 1.0f);
952
953         /* body */
954         UI_ThemeColor(color_id);
955         if (node->flag & NODE_MUTED)
956                 UI_ThemeColorBlend(color_id, TH_REDALERT, 0.5f);
957
958 #ifdef WITH_COMPOSITOR
959         if (ntree->type == NTREE_COMPOSIT && (snode->flag & SNODE_SHOW_HIGHLIGHT)) {
960                 if (COM_isHighlightedbNode(node)) {
961                         UI_ThemeColorBlend(color_id, TH_ACTIVE, 0.5f);
962                 }
963         }
964 #else
965         (void)ntree;
966 #endif
967         
968         uiRoundBox(rct->xmin, rct->ymin, rct->xmax, rct->ymax, hiddenrad);
969         
970         /* outline active and selected emphasis */
971         if (node->flag & SELECT) {
972                 glEnable(GL_BLEND);
973                 glEnable(GL_LINE_SMOOTH);
974                 
975                 if (node->flag & NODE_ACTIVE)
976                         UI_ThemeColorShadeAlpha(TH_ACTIVE, 0, -40);
977                 else
978                         UI_ThemeColorShadeAlpha(TH_SELECT, 0, -40);
979                 uiDrawBox(GL_LINE_LOOP, rct->xmin, rct->ymin, rct->xmax, rct->ymax, hiddenrad);
980                 
981                 glDisable(GL_LINE_SMOOTH);
982                 glDisable(GL_BLEND);
983         }
984
985         /* custom color inline */
986         if (node->flag & NODE_CUSTOM_COLOR) {
987                 glEnable(GL_BLEND);
988                 glEnable(GL_LINE_SMOOTH);
989
990                 glColor3fv(node->color);
991                 uiDrawBox(GL_LINE_LOOP, rct->xmin + 1, rct->ymin + 1, rct->xmax -1, rct->ymax - 1, hiddenrad);
992
993                 glDisable(GL_LINE_SMOOTH);
994                 glDisable(GL_BLEND);
995         }
996
997         /* title */
998         if (node->flag & SELECT) 
999                 UI_ThemeColor(TH_SELECT);
1000         else
1001                 UI_ThemeColorBlendShade(TH_TEXT, color_id, 0.4f, 10);
1002         
1003         /* open entirely icon */
1004         {
1005                 uiBut *but;
1006                 int but_size = UI_UNIT_X * 0.6f;
1007                 /* XXX button uses a custom triangle draw below, so make it invisible without icon */
1008                 uiBlockSetEmboss(node->block, UI_EMBOSSN);
1009                 but = uiDefBut(node->block, TOGBUT, B_REDR, "",
1010                                rct->xmin + 10.0f - but_size / 2, centy - but_size / 2,
1011                                but_size, but_size, NULL, 0, 0, 0, 0, "");
1012                 uiButSetFunc(but, node_toggle_button_cb, node, (void *)"NODE_OT_hide_toggle");
1013                 uiBlockSetEmboss(node->block, UI_EMBOSS);
1014                 
1015                 /* custom draw function for this button */
1016                 UI_DrawTriIcon(rct->xmin + 10.0f, centy, 'h');
1017         }
1018         
1019         /* disable lines */
1020         if (node->flag & NODE_MUTED)
1021                 node_draw_mute_line(&ar->v2d, snode, node);
1022         
1023         if (node->flag & SELECT) 
1024                 UI_ThemeColor(TH_SELECT);
1025         else
1026                 UI_ThemeColor(TH_TEXT);
1027         
1028         if (node->miniwidth > 0.0f) {
1029                 BLI_strncpy(showname, nodeLabel(node), sizeof(showname));
1030                 
1031                 //if (node->flag & NODE_MUTED)
1032                 //      BLI_snprintf(showname, sizeof(showname), "[%s]", showname); /* XXX - don't print into self! */
1033
1034                 uiDefBut(node->block, LABEL, 0, showname,
1035                          (int)(rct->xmin + (NODE_MARGIN_X)), (int)(centy - 10),
1036                          (short)(BLI_rctf_size_x(rct) - 18.0f - 12.0f), (short)NODE_DY,
1037                          NULL, 0, 0, 0, 0, "");
1038         }
1039
1040         /* scale widget thing */
1041         UI_ThemeColorShade(color_id, -10);
1042         dx = 10.0f;
1043         fdrawline(rct->xmax - dx, centy - 4.0f, rct->xmax - dx, centy + 4.0f);
1044         fdrawline(rct->xmax - dx - 3.0f * snode->aspect, centy - 4.0f, rct->xmax - dx - 3.0f * snode->aspect, centy + 4.0f);
1045         
1046         UI_ThemeColorShade(color_id, +30);
1047         dx -= snode->aspect;
1048         fdrawline(rct->xmax - dx, centy - 4.0f, rct->xmax - dx, centy + 4.0f);
1049         fdrawline(rct->xmax - dx - 3.0f * snode->aspect, centy - 4.0f, rct->xmax - dx - 3.0f * snode->aspect, centy + 4.0f);
1050
1051         /* sockets */
1052         for (sock = node->inputs.first; sock; sock = sock->next) {
1053                 if (!nodeSocketIsHidden(sock))
1054                         node_socket_circle_draw(C, ntree, node, sock, socket_size, sock->flag & SELECT);
1055         }
1056         
1057         for (sock = node->outputs.first; sock; sock = sock->next) {
1058                 if (!nodeSocketIsHidden(sock))
1059                         node_socket_circle_draw(C, ntree, node, sock, socket_size, sock->flag & SELECT);
1060         }
1061         
1062         uiEndBlock(C, node->block);
1063         uiDrawBlock(C, node->block);
1064         node->block = NULL;
1065 }
1066
1067 int node_get_resize_cursor(int directions)
1068 {
1069         if (directions == 0)
1070                 return CURSOR_STD;
1071         else if ((directions & ~(NODE_RESIZE_TOP | NODE_RESIZE_BOTTOM)) == 0)
1072                 return CURSOR_Y_MOVE;
1073         else if ((directions & ~(NODE_RESIZE_RIGHT | NODE_RESIZE_LEFT)) == 0)
1074                 return CURSOR_X_MOVE;
1075         else
1076                 return CURSOR_EDIT;
1077 }
1078
1079 void node_set_cursor(wmWindow *win, SpaceNode *snode)
1080 {
1081         bNodeTree *ntree = snode->edittree;
1082         bNode *node;
1083         bNodeSocket *sock;
1084         int cursor = CURSOR_STD;
1085         
1086         if (ntree) {
1087                 if (node_find_indicated_socket(snode, &node, &sock, SOCK_IN | SOCK_OUT)) {
1088                         /* pass */
1089                 }
1090                 else {
1091                         /* check nodes front to back */
1092                         for (node = ntree->nodes.last; node; node = node->prev) {
1093                                 if (BLI_rctf_isect_pt(&node->totr, snode->cursor[0], snode->cursor[1]))
1094                                         break;  /* first hit on node stops */
1095                         }
1096                         if (node) {
1097                                 int dir = node->typeinfo->resize_area_func(node, snode->cursor[0], snode->cursor[1]);
1098                                 cursor = node_get_resize_cursor(dir);
1099                         }
1100                 }
1101         }
1102         
1103         WM_cursor_set(win, cursor);
1104 }
1105
1106 void node_draw_default(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key)
1107 {
1108         if (node->flag & NODE_HIDDEN)
1109                 node_draw_hidden(C, ar, snode, ntree, node, key);
1110         else
1111                 node_draw_basis(C, ar, snode, ntree, node, key);
1112 }
1113
1114 static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
1115 {
1116         if (node->typeinfo->drawupdatefunc)
1117                 node->typeinfo->drawupdatefunc(C, ntree, node);
1118 }
1119
1120 void node_update_nodetree(const bContext *C, bNodeTree *ntree)
1121 {
1122         bNode *node;
1123         
1124         /* update nodes front to back, so children sizes get updated before parents */
1125         for (node = ntree->nodes.last; node; node = node->prev) {
1126                 node_update(C, ntree, node);
1127         }
1128 }
1129
1130 static void node_draw(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key)
1131 {
1132         if (node->typeinfo->drawfunc)
1133                 node->typeinfo->drawfunc(C, ar, snode, ntree, node, key);
1134 }
1135
1136 #define USE_DRAW_TOT_UPDATE
1137
1138 void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNodeInstanceKey parent_key)
1139 {
1140         bNode *node;
1141         bNodeLink *link;
1142         int a;
1143         
1144         if (ntree == NULL) return;      /* groups... */
1145
1146 #ifdef USE_DRAW_TOT_UPDATE
1147         if (ntree->nodes.first) {
1148                 BLI_rctf_init_minmax(&ar->v2d.tot);
1149         }
1150 #endif
1151
1152         /* draw background nodes, last nodes in front */
1153         for (a = 0, node = ntree->nodes.first; node; node = node->next, a++) {
1154                 bNodeInstanceKey key;
1155
1156 #ifdef USE_DRAW_TOT_UPDATE
1157                 /* unrelated to background nodes, update the v2d->tot,
1158                  * can be anywhere before we draw the scroll bars */
1159                 BLI_rctf_union(&ar->v2d.tot, &node->totr);
1160 #endif
1161
1162                 if (!(node->flag & NODE_BACKGROUND))
1163                         continue;
1164
1165                 key = BKE_node_instance_key(parent_key, ntree, node);
1166                 node->nr = a;        /* index of node in list, used for exec event code */
1167                 node_draw(C, ar, snode, ntree, node, key);
1168         }
1169         
1170         /* node lines */
1171         glEnable(GL_BLEND);
1172         glEnable(GL_LINE_SMOOTH);
1173         for (link = ntree->links.first; link; link = link->next) {
1174                 if (!nodeLinkIsHidden(link))
1175                         node_draw_link(&ar->v2d, snode, link);
1176         }
1177         glDisable(GL_LINE_SMOOTH);
1178         glDisable(GL_BLEND);
1179         
1180         /* draw foreground nodes, last nodes in front */
1181         for (a = 0, node = ntree->nodes.first; node; node = node->next, a++) {
1182                 bNodeInstanceKey key;
1183                 if (node->flag & NODE_BACKGROUND)
1184                         continue;
1185
1186                 key = BKE_node_instance_key(parent_key, ntree, node);
1187                 node->nr = a;        /* index of node in list, used for exec event code */
1188                 node_draw(C, ar, snode, ntree, node, key);
1189         }
1190 }
1191
1192 /* draw tree path info in lower left corner */
1193 static void draw_tree_path(SpaceNode *snode)
1194 {
1195         char info[256];
1196         
1197         ED_node_tree_path_get_fixedbuf(snode, info, sizeof(info));
1198         
1199         UI_ThemeColor(TH_TEXT_HI);
1200         BLF_draw_default(1.5f * UI_UNIT_X, 1.5f * UI_UNIT_Y, 0.0f, info, sizeof(info));
1201 }
1202
1203 static void snode_setup_v2d(SpaceNode *snode, ARegion *ar, const float center[2])
1204 {
1205         View2D *v2d = &ar->v2d;
1206         
1207         /* shift view to node tree center */
1208         UI_view2d_setcenter(v2d, center[0], center[1]);
1209         UI_view2d_view_ortho(v2d);
1210         
1211         /* aspect+font, set each time */
1212         snode->aspect = BLI_rctf_size_x(&v2d->cur) / (float)ar->winx;
1213         // XXX snode->curfont = uiSetCurFont_ext(snode->aspect);
1214 }
1215
1216 static void draw_nodetree(const bContext *C, ARegion *ar, bNodeTree *ntree, bNodeInstanceKey parent_key)
1217 {
1218         SpaceNode *snode = CTX_wm_space_node(C);
1219         
1220         node_uiblocks_init(C, ntree);
1221         
1222 #ifdef WITH_COMPOSITOR
1223         if (ntree->type == NTREE_COMPOSIT) {
1224                 COM_startReadHighlights();
1225         }
1226 #endif
1227         
1228         node_update_nodetree(C, ntree);
1229         node_draw_nodetree(C, ar, snode, ntree, parent_key);
1230 }
1231
1232 /* shade the parent node group and add a uiBlock to clip mouse events */
1233 static void draw_group_overlay(const bContext *C, ARegion *ar)
1234 {
1235         View2D *v2d = &ar->v2d;
1236         rctf rect = v2d->cur;
1237         uiBlock *block;
1238         
1239         /* shade node groups to separate them visually */
1240         UI_ThemeColorShadeAlpha(TH_NODE_GROUP, 0, -70);
1241         glEnable(GL_BLEND);
1242         uiSetRoundBox(0);
1243         uiDrawBox(GL_POLYGON, rect.xmin, rect.ymin, rect.xmax, rect.ymax, 0);
1244         glDisable(GL_BLEND);
1245         
1246         /* set the block bounds to clip mouse events from underlying nodes */
1247         block = uiBeginBlock(C, ar, "node tree bounds block", UI_EMBOSS);
1248         uiExplicitBoundsBlock(block, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
1249         uiBlockSetFlag(block, UI_BLOCK_CLIP_EVENTS);
1250         uiEndBlock(C, block);
1251 }
1252
1253 void drawnodespace(const bContext *C, ARegion *ar)
1254 {
1255         View2DScrollers *scrollers;
1256         SpaceNode *snode = CTX_wm_space_node(C);
1257         View2D *v2d = &ar->v2d;
1258
1259         UI_ThemeClearColor(TH_BACK);
1260         glClear(GL_COLOR_BUFFER_BIT);
1261
1262         UI_view2d_view_ortho(v2d);
1263
1264         ED_region_draw_cb_draw(C, ar, REGION_DRAW_PRE_VIEW);
1265
1266         /* only set once */
1267         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1268         glEnable(GL_MAP1_VERTEX_3);
1269         
1270         /* nodes */
1271         snode_set_context(C);
1272         
1273         /* draw parent node trees */
1274         if (snode->treepath.last) {
1275                 static const int max_depth = 2;
1276                 bNodeTreePath *path;
1277                 int depth, curdepth;
1278                 float center[2];
1279                 bNodeTree *ntree;
1280                 bNodeLinkDrag *nldrag;
1281                 LinkData *linkdata;
1282                 
1283                 path = snode->treepath.last;
1284                 
1285                 /* current View2D center, will be set temporarily for parent node trees */
1286                 UI_view2d_getcenter(v2d, &center[0], &center[1]);
1287                 
1288                 /* store new view center in path and current edittree */
1289                 copy_v2_v2(path->view_center, center);
1290                 if (snode->edittree)
1291                         copy_v2_v2(snode->edittree->view_center, center);
1292                 
1293                 depth = 0;
1294                 while (path->prev && depth < max_depth) {
1295                         path = path->prev;
1296                         ++depth;
1297                 }
1298                 
1299                 /* parent node trees in the background */
1300                 for (curdepth = depth; curdepth > 0; path = path->next, --curdepth) {
1301                         ntree = path->nodetree;
1302                         if (ntree) {
1303                                 snode_setup_v2d(snode, ar, path->view_center);
1304                                 
1305                                 draw_nodetree(C, ar, ntree, path->parent_key);
1306                                 
1307                                 draw_group_overlay(C, ar);
1308                         }
1309                 }
1310                 
1311                 /* top-level edit tree */
1312                 ntree = path->nodetree;
1313                 if (ntree) {
1314                         snode_setup_v2d(snode, ar, center);
1315                         
1316                         /* grid, uses theme color based on node path depth */
1317                         UI_view2d_multi_grid_draw(v2d, (depth > 0 ? TH_NODE_GROUP : TH_BACK), U.widget_unit, 5, 2);
1318                         
1319                         /* backdrop */
1320                         draw_nodespace_back_pix(C, ar, snode, path->parent_key);
1321                         
1322                         draw_nodetree(C, ar, ntree, path->parent_key);
1323                 }
1324                 
1325                 /* temporary links */
1326                 glEnable(GL_BLEND);
1327                 glEnable(GL_LINE_SMOOTH);
1328                 for (nldrag = snode->linkdrag.first; nldrag; nldrag = nldrag->next) {
1329                         for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next)
1330                                 node_draw_link(v2d, snode, (bNodeLink *)linkdata->data);
1331                 }
1332                 glDisable(GL_LINE_SMOOTH);
1333                 glDisable(GL_BLEND);
1334                 
1335                 if (snode->flag & SNODE_SHOW_GPENCIL) {
1336                         /* draw grease-pencil ('canvas' strokes) */
1337                         draw_gpencil_view2d(C, TRUE);
1338                 }
1339         }
1340         else {
1341                 /* default grid */
1342                 UI_view2d_multi_grid_draw(v2d, TH_BACK, U.widget_unit, 5, 2);
1343                 
1344                 /* backdrop */
1345                 draw_nodespace_back_pix(C, ar, snode, NODE_INSTANCE_KEY_NONE);
1346         }
1347         
1348         ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);
1349         
1350         /* reset view matrix */
1351         UI_view2d_view_restore(C);
1352         
1353         if (snode->treepath.last) {
1354                 if (snode->flag & SNODE_SHOW_GPENCIL) {
1355                         /* draw grease-pencil (screen strokes, and also paintbuffer) */
1356                         draw_gpencil_view2d(C, FALSE);
1357                 }
1358         }
1359
1360         /* tree path info */
1361         draw_tree_path(snode);
1362         
1363         /* scrollers */
1364         scrollers = UI_view2d_scrollers_calc(C, v2d, 10, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
1365         UI_view2d_scrollers_draw(C, v2d, scrollers);
1366         UI_view2d_scrollers_free(scrollers);
1367 }