7572ca04a3327f88d6aca5906e13fa745b4ae471
[blender.git] / source / blender / editors / space_node / node_group.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, Nathan Letwory
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_node/node_group.c
29  *  \ingroup spnode
30  */
31
32 #include <stdlib.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_node_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_anim_types.h"
39
40 #include "BLI_listbase.h"
41 #include "BLI_string.h"
42 #include "BLI_rect.h"
43 #include "BLI_math.h"
44
45 #include "BKE_action.h"
46 #include "BKE_animsys.h"
47 #include "BKE_context.h"
48 #include "BKE_global.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_report.h"
52
53 #include "ED_node.h"  /* own include */
54 #include "ED_screen.h"
55 #include "ED_render.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59 #include "RNA_enum_types.h"
60
61 #include "WM_api.h"
62 #include "WM_types.h"
63
64 #include "UI_resources.h"
65
66 #include "node_intern.h"  /* own include */
67 #include "NOD_socket.h"
68
69 static EnumPropertyItem socket_in_out_items[] = {
70         { SOCK_IN, "SOCK_IN", 0, "Input", "" },
71         { SOCK_OUT, "SOCK_OUT", 0, "Output", "" },
72         { 0, NULL, 0, NULL, NULL },
73 };
74
75 /* ***************** Edit Group operator ************* */
76
77 void snode_make_group_editable(SpaceNode *snode, bNode *gnode)
78 {
79         bNode *node;
80
81         /* make sure nothing has group editing on */
82         for (node = snode->nodetree->nodes.first; node; node = node->next) {
83                 nodeGroupEditClear(node);
84
85                 /* while we're here, clear texture active */
86                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
87                         /* this is not 100% sure to be reliable, see comment on the flag */
88                         node->flag &= ~NODE_ACTIVE_TEXTURE;
89                 }
90         }
91
92         if (gnode == NULL) {
93                 /* with NULL argument we do a toggle */
94                 if (snode->edittree == snode->nodetree)
95                         gnode = nodeGetActive(snode->nodetree);
96         }
97
98         if (gnode) {
99                 snode->edittree = nodeGroupEditSet(gnode, 1);
100
101                 /* deselect all other nodes, so we can also do grabbing of entire subtree */
102                 for (node = snode->nodetree->nodes.first; node; node = node->next) {
103                         node_deselect(node);
104
105                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
106                                 /* this is not 100% sure to be reliable, see comment on the flag */
107                                 node->flag &= ~NODE_ACTIVE_TEXTURE;
108                         }
109                 }
110                 node_select(gnode);
111         }
112         else
113                 snode->edittree = snode->nodetree;
114 }
115
116 static int node_group_edit_exec(bContext *C, wmOperator *UNUSED(op))
117 {
118         SpaceNode *snode = CTX_wm_space_node(C);
119
120         ED_preview_kill_jobs(C);
121
122         if (snode->nodetree == snode->edittree) {
123                 bNode *gnode = nodeGetActive(snode->edittree);
124                 snode_make_group_editable(snode, gnode);
125         }
126         else
127                 snode_make_group_editable(snode, NULL);
128
129         WM_event_add_notifier(C, NC_SCENE | ND_NODES, NULL);
130
131         return OPERATOR_FINISHED;
132 }
133
134 static int node_group_edit_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
135 {
136         SpaceNode *snode = CTX_wm_space_node(C);
137         bNode *gnode;
138
139         /* XXX callback? */
140         if (snode->nodetree == snode->edittree) {
141                 gnode = nodeGetActive(snode->edittree);
142                 if (gnode && gnode->id && GS(gnode->id->name) == ID_NT && gnode->id->lib) {
143                         uiPupMenuOkee(C, op->type->idname, "Make group local?");
144                         return OPERATOR_CANCELLED;
145                 }
146         }
147
148         return node_group_edit_exec(C, op);
149 }
150
151 void NODE_OT_group_edit(wmOperatorType *ot)
152 {
153         /* identifiers */
154         ot->name = "Edit Group";
155         ot->description = "Edit node group";
156         ot->idname = "NODE_OT_group_edit";
157
158         /* api callbacks */
159         ot->invoke = node_group_edit_invoke;
160         ot->exec = node_group_edit_exec;
161         ot->poll = ED_operator_node_active;
162
163         /* flags */
164         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
165 }
166
167 /* ***************** Add Group Socket operator ************* */
168
169 static int node_group_socket_add_exec(bContext *C, wmOperator *op)
170 {
171         SpaceNode *snode = CTX_wm_space_node(C);
172         int in_out = -1;
173         char name[MAX_NAME] = "";
174         int type = SOCK_FLOAT;
175         bNodeTree *ngroup = snode->edittree;
176         /* bNodeSocket *sock; */ /* UNUSED */
177
178         ED_preview_kill_jobs(C);
179
180         if (RNA_struct_property_is_set(op->ptr, "name"))
181                 RNA_string_get(op->ptr, "name", name);
182
183         if (RNA_struct_property_is_set(op->ptr, "type"))
184                 type = RNA_enum_get(op->ptr, "type");
185
186         if (RNA_struct_property_is_set(op->ptr, "in_out"))
187                 in_out = RNA_enum_get(op->ptr, "in_out");
188         else
189                 return OPERATOR_CANCELLED;
190
191         /* using placeholder subtype first */
192         /* sock = */ /* UNUSED */ node_group_add_socket(ngroup, name, type, in_out);
193
194         ntreeUpdateTree(ngroup);
195
196         snode_notify(C, snode);
197
198         return OPERATOR_FINISHED;
199 }
200
201 void NODE_OT_group_socket_add(wmOperatorType *ot)
202 {
203         /* identifiers */
204         ot->name = "Add Group Socket";
205         ot->description = "Add node group socket";
206         ot->idname = "NODE_OT_group_socket_add";
207
208         /* api callbacks */
209         ot->exec = node_group_socket_add_exec;
210         ot->poll = ED_operator_node_active;
211
212         /* flags */
213         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
214
215         RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
216         RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Group socket name");
217         RNA_def_enum(ot->srna, "type", node_socket_type_items, SOCK_FLOAT, "Type", "Type of the group socket");
218 }
219
220 /* ***************** Remove Group Socket operator ************* */
221
222 static int node_group_socket_remove_exec(bContext *C, wmOperator *op)
223 {
224         SpaceNode *snode = CTX_wm_space_node(C);
225         int index = -1;
226         int in_out = -1;
227         bNodeTree *ngroup = snode->edittree;
228         bNodeSocket *sock;
229
230         ED_preview_kill_jobs(C);
231
232         if (RNA_struct_property_is_set(op->ptr, "index"))
233                 index = RNA_int_get(op->ptr, "index");
234         else
235                 return OPERATOR_CANCELLED;
236
237         if (RNA_struct_property_is_set(op->ptr, "in_out"))
238                 in_out = RNA_enum_get(op->ptr, "in_out");
239         else
240                 return OPERATOR_CANCELLED;
241
242         sock = (bNodeSocket *)BLI_findlink(in_out == SOCK_IN ? &ngroup->inputs : &ngroup->outputs, index);
243         if (sock) {
244                 node_group_remove_socket(ngroup, sock, in_out);
245                 ntreeUpdateTree(ngroup);
246
247                 snode_notify(C, snode);
248         }
249
250         return OPERATOR_FINISHED;
251 }
252
253 void NODE_OT_group_socket_remove(wmOperatorType *ot)
254 {
255         /* identifiers */
256         ot->name = "Remove Group Socket";
257         ot->description = "Remove a node group socket";
258         ot->idname = "NODE_OT_group_socket_remove";
259
260         /* api callbacks */
261         ot->exec = node_group_socket_remove_exec;
262         ot->poll = ED_operator_node_active;
263
264         /* flags */
265         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
266
267         RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
268         RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
269 }
270
271 /* ***************** Move Group Socket Up operator ************* */
272
273 static int node_group_socket_move_up_exec(bContext *C, wmOperator *op)
274 {
275         SpaceNode *snode = CTX_wm_space_node(C);
276         int index = -1;
277         int in_out = -1;
278         bNodeTree *ngroup = snode->edittree;
279         bNodeSocket *sock, *prev;
280
281         ED_preview_kill_jobs(C);
282
283         if (RNA_struct_property_is_set(op->ptr, "index"))
284                 index = RNA_int_get(op->ptr, "index");
285         else
286                 return OPERATOR_CANCELLED;
287
288         if (RNA_struct_property_is_set(op->ptr, "in_out"))
289                 in_out = RNA_enum_get(op->ptr, "in_out");
290         else
291                 return OPERATOR_CANCELLED;
292
293         /* swap */
294         if (in_out == SOCK_IN) {
295                 sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index);
296                 prev = sock->prev;
297                 /* can't move up the first socket */
298                 if (!prev)
299                         return OPERATOR_CANCELLED;
300                 BLI_remlink(&ngroup->inputs, sock);
301                 BLI_insertlinkbefore(&ngroup->inputs, prev, sock);
302
303                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
304         }
305         else if (in_out == SOCK_OUT) {
306                 sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index);
307                 prev = sock->prev;
308                 /* can't move up the first socket */
309                 if (!prev)
310                         return OPERATOR_CANCELLED;
311                 BLI_remlink(&ngroup->outputs, sock);
312                 BLI_insertlinkbefore(&ngroup->outputs, prev, sock);
313
314                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
315         }
316         ntreeUpdateTree(ngroup);
317
318         snode_notify(C, snode);
319
320         return OPERATOR_FINISHED;
321 }
322
323 void NODE_OT_group_socket_move_up(wmOperatorType *ot)
324 {
325         /* identifiers */
326         ot->name = "Move Group Socket Up";
327         ot->description = "Move up node group socket";
328         ot->idname = "NODE_OT_group_socket_move_up";
329
330         /* api callbacks */
331         ot->exec = node_group_socket_move_up_exec;
332         ot->poll = ED_operator_node_active;
333
334         /* flags */
335         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
336
337         RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
338         RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
339 }
340
341 /* ***************** Move Group Socket Up operator ************* */
342
343 static int node_group_socket_move_down_exec(bContext *C, wmOperator *op)
344 {
345         SpaceNode *snode = CTX_wm_space_node(C);
346         int index = -1;
347         int in_out = -1;
348         bNodeTree *ngroup = snode->edittree;
349         bNodeSocket *sock, *next;
350
351         ED_preview_kill_jobs(C);
352
353         if (RNA_struct_property_is_set(op->ptr, "index"))
354                 index = RNA_int_get(op->ptr, "index");
355         else
356                 return OPERATOR_CANCELLED;
357
358         if (RNA_struct_property_is_set(op->ptr, "in_out"))
359                 in_out = RNA_enum_get(op->ptr, "in_out");
360         else
361                 return OPERATOR_CANCELLED;
362
363         /* swap */
364         if (in_out == SOCK_IN) {
365                 sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index);
366                 next = sock->next;
367                 /* can't move down the last socket */
368                 if (!next)
369                         return OPERATOR_CANCELLED;
370                 BLI_remlink(&ngroup->inputs, sock);
371                 BLI_insertlinkafter(&ngroup->inputs, next, sock);
372
373                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
374         }
375         else if (in_out == SOCK_OUT) {
376                 sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index);
377                 next = sock->next;
378                 /* can't move down the last socket */
379                 if (!next)
380                         return OPERATOR_CANCELLED;
381                 BLI_remlink(&ngroup->outputs, sock);
382                 BLI_insertlinkafter(&ngroup->outputs, next, sock);
383
384                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
385         }
386         ntreeUpdateTree(ngroup);
387
388         snode_notify(C, snode);
389
390         return OPERATOR_FINISHED;
391 }
392
393 void NODE_OT_group_socket_move_down(wmOperatorType *ot)
394 {
395         /* identifiers */
396         ot->name = "Move Group Socket Down";
397         ot->description = "Move down node group socket";
398         ot->idname = "NODE_OT_group_socket_move_down";
399
400         /* api callbacks */
401         ot->exec = node_group_socket_move_down_exec;
402         ot->poll = ED_operator_node_active;
403
404         /* flags */
405         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
406
407         RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
408         RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
409 }
410
411 /* ******************** Ungroup operator ********************** */
412
413 /* returns 1 if its OK */
414 static int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
415 {
416         bNodeLink *link, *linkn;
417         bNode *node, *nextn;
418         bNodeTree *ngroup, *wgroup;
419         ListBase anim_basepaths = {NULL, NULL};
420
421         ngroup = (bNodeTree *)gnode->id;
422         if (ngroup == NULL) return 0;
423
424         /* clear new pointers, set in copytree */
425         for (node = ntree->nodes.first; node; node = node->next)
426                 node->new_node = NULL;
427
428         /* wgroup is a temporary copy of the NodeTree we're merging in
429          * - all of wgroup's nodes are transferred across to their new home
430          * - ngroup (i.e. the source NodeTree) is left unscathed
431          * - temp copy. don't change ID usercount
432          */
433         wgroup = ntreeCopyTree_ex(ngroup, FALSE);
434
435         /* add the nodes into the ntree */
436         for (node = wgroup->nodes.first; node; node = nextn) {
437                 nextn = node->next;
438
439                 /* keep track of this node's RNA "base" path (the part of the path identifying the node)
440                  * if the old nodetree has animation data which potentially covers this node
441                  */
442                 if (wgroup->adt) {
443                         PointerRNA ptr;
444                         char *path;
445
446                         RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
447                         path = RNA_path_from_ID_to_struct(&ptr);
448
449                         if (path)
450                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
451                 }
452
453                 /* migrate node */
454                 BLI_remlink(&wgroup->nodes, node);
455                 BLI_addtail(&ntree->nodes, node);
456
457                 /* ensure unique node name in the nodee tree */
458                 nodeUniqueName(ntree, node);
459
460                 node->locx += gnode->locx;
461                 node->locy += gnode->locy;
462
463                 node->flag |= NODE_SELECT;
464         }
465
466         /* restore external links to and from the gnode */
467         for (link = ntree->links.first; link; link = link->next) {
468                 if (link->fromnode == gnode) {
469                         if (link->fromsock->groupsock) {
470                                 bNodeSocket *gsock = link->fromsock->groupsock;
471                                 if (gsock->link) {
472                                         if (gsock->link->fromnode) {
473                                                 /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
474                                                 link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
475                                                 link->fromsock = gsock->link->fromsock->new_sock;
476                                         }
477                                         else {
478                                                 /* group output directly maps to group input */
479                                                 bNodeSocket *insock = node_group_find_input(gnode, gsock->link->fromsock);
480                                                 if (insock->link) {
481                                                         link->fromnode = insock->link->fromnode;
482                                                         link->fromsock = insock->link->fromsock;
483                                                 }
484                                         }
485                                 }
486                                 else {
487                                         /* copy the default input value from the group socket default to the external socket */
488                                         node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value);
489                                 }
490                         }
491                 }
492         }
493         /* remove internal output links, these are not used anymore */
494         for (link = wgroup->links.first; link; link = linkn) {
495                 linkn = link->next;
496                 if (!link->tonode)
497                         nodeRemLink(wgroup, link);
498         }
499         /* restore links from internal nodes */
500         for (link = wgroup->links.first; link; link = linkn) {
501                 linkn = link->next;
502                 /* indicates link to group input */
503                 if (!link->fromnode) {
504                         /* NB: can't use find_group_node_input here,
505                          * because gnode sockets still point to the old tree!
506                          */
507                         bNodeSocket *insock;
508                         for (insock = gnode->inputs.first; insock; insock = insock->next)
509                                 if (insock->groupsock->new_sock == link->fromsock)
510                                         break;
511                         if (insock->link) {
512                                 link->fromnode = insock->link->fromnode;
513                                 link->fromsock = insock->link->fromsock;
514                         }
515                         else {
516                                 /* copy the default input value from the group node socket default to the internal socket */
517                                 node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value);
518                                 nodeRemLink(wgroup, link);
519                         }
520                 }
521         }
522
523         /* add internal links to the ntree */
524         for (link = wgroup->links.first; link; link = linkn) {
525                 linkn = link->next;
526                 BLI_remlink(&wgroup->links, link);
527                 BLI_addtail(&ntree->links, link);
528         }
529
530         /* and copy across the animation,
531          * note that the animation data's action can be NULL here */
532         if (wgroup->adt) {
533                 LinkData *ld, *ldn = NULL;
534                 bAction *waction;
535
536                 /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
537                 waction = wgroup->adt->action = BKE_action_copy(wgroup->adt->action);
538
539                 /* now perform the moving */
540                 BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
541
542                 /* paths + their wrappers need to be freed */
543                 for (ld = anim_basepaths.first; ld; ld = ldn) {
544                         ldn = ld->next;
545
546                         MEM_freeN(ld->data);
547                         BLI_freelinkN(&anim_basepaths, ld);
548                 }
549
550                 /* free temp action too */
551                 if (waction) {
552                         BKE_libblock_free(&G.main->action, waction);
553                 }
554         }
555
556         /* delete the group instance. this also removes old input links! */
557         nodeFreeNode(ntree, gnode);
558
559         /* free the group tree (takes care of user count) */
560         BKE_libblock_free(&G.main->nodetree, wgroup);
561
562         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
563
564         return 1;
565 }
566
567 static int node_group_ungroup_exec(bContext *C, wmOperator *op)
568 {
569         SpaceNode *snode = CTX_wm_space_node(C);
570         bNode *gnode;
571
572         ED_preview_kill_jobs(C);
573
574         /* are we inside of a group? */
575         gnode = node_tree_get_editgroup(snode->nodetree);
576         if (gnode)
577                 snode_make_group_editable(snode, NULL);
578
579         gnode = nodeGetActive(snode->edittree);
580         if (gnode == NULL)
581                 return OPERATOR_CANCELLED;
582
583         if (gnode->type != NODE_GROUP) {
584                 BKE_report(op->reports, RPT_WARNING, "Not a group");
585                 return OPERATOR_CANCELLED;
586         }
587         else if (node_group_ungroup(snode->nodetree, gnode)) {
588                 ntreeUpdateTree(snode->nodetree);
589         }
590         else {
591                 BKE_report(op->reports, RPT_WARNING, "Cannot ungroup");
592                 return OPERATOR_CANCELLED;
593         }
594
595         snode_notify(C, snode);
596         snode_dag_update(C, snode);
597
598         return OPERATOR_FINISHED;
599 }
600
601 void NODE_OT_group_ungroup(wmOperatorType *ot)
602 {
603         /* identifiers */
604         ot->name = "Ungroup";
605         ot->description = "Ungroup selected nodes";
606         ot->idname = "NODE_OT_group_ungroup";
607
608         /* api callbacks */
609         ot->exec = node_group_ungroup_exec;
610         ot->poll = ED_operator_node_active;
611
612         /* flags */
613         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
614 }
615
616 /* ******************** Separate operator ********************** */
617
618 /* returns 1 if its OK */
619 static int node_group_separate_selected(bNodeTree *ntree, bNode *gnode, int make_copy)
620 {
621         bNodeLink *link, *link_next;
622         bNode *node, *node_next, *newnode;
623         bNodeTree *ngroup;
624         ListBase anim_basepaths = {NULL, NULL};
625
626         ngroup = (bNodeTree *)gnode->id;
627         if (ngroup == NULL) return 0;
628
629         /* deselect all nodes in the target tree */
630         for (node = ntree->nodes.first; node; node = node->next)
631                 node_deselect(node);
632
633         /* clear new pointers, set in nodeCopyNode */
634         for (node = ngroup->nodes.first; node; node = node->next)
635                 node->new_node = NULL;
636
637         /* add selected nodes into the ntree */
638         for (node = ngroup->nodes.first; node; node = node_next) {
639                 node_next = node->next;
640                 if (node->flag & NODE_SELECT) {
641                         
642                         if (make_copy) {
643                                 /* make a copy */
644                                 newnode = nodeCopyNode(ngroup, node);
645                         }
646                         else {
647                                 /* use the existing node */
648                                 newnode = node;
649                         }
650                         
651                         /* keep track of this node's RNA "base" path (the part of the path identifying the node)
652                          * if the old nodetree has animation data which potentially covers this node
653                          */
654                         if (ngroup->adt) {
655                                 PointerRNA ptr;
656                                 char *path;
657                                 
658                                 RNA_pointer_create(&ngroup->id, &RNA_Node, newnode, &ptr);
659                                 path = RNA_path_from_ID_to_struct(&ptr);
660                                 
661                                 if (path)
662                                         BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
663                         }
664                         
665                         /* ensure valid parent pointers, detach if parent stays inside the group */
666                         if (newnode->parent && !(newnode->parent->flag & NODE_SELECT))
667                                 nodeDetachNode(newnode);
668                         
669                         /* migrate node */
670                         BLI_remlink(&ngroup->nodes, newnode);
671                         BLI_addtail(&ntree->nodes, newnode);
672                         
673                         /* ensure unique node name in the node tree */
674                         nodeUniqueName(ntree, newnode);
675                         
676                         newnode->locx += gnode->locx;
677                         newnode->locy += gnode->locy;
678                 }
679                 else {
680                         /* ensure valid parent pointers, detach if child stays inside the group */
681                         if (node->parent && (node->parent->flag & NODE_SELECT))
682                                 nodeDetachNode(node);
683                 }
684         }
685
686         /* add internal links to the ntree */
687         for (link = ngroup->links.first; link; link = link_next) {
688                 int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT));
689                 int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT));
690                 link_next = link->next;
691
692                 if (make_copy) {
693                         /* make a copy of internal links */
694                         if (fromselect && toselect)
695                                 nodeAddLink(ntree, link->fromnode->new_node, link->fromsock->new_sock, link->tonode->new_node, link->tosock->new_sock);
696                 }
697                 else {
698                         /* move valid links over, delete broken links */
699                         if (fromselect && toselect) {
700                                 BLI_remlink(&ngroup->links, link);
701                                 BLI_addtail(&ntree->links, link);
702                         }
703                         else if (fromselect || toselect) {
704                                 nodeRemLink(ngroup, link);
705                         }
706                 }
707         }
708
709         /* and copy across the animation,
710          * note that the animation data's action can be NULL here */
711         if (ngroup->adt) {
712                 LinkData *ld, *ldn = NULL;
713
714                 /* now perform the moving */
715                 BKE_animdata_separate_by_basepath(&ngroup->id, &ntree->id, &anim_basepaths);
716
717                 /* paths + their wrappers need to be freed */
718                 for (ld = anim_basepaths.first; ld; ld = ldn) {
719                         ldn = ld->next;
720
721                         MEM_freeN(ld->data);
722                         BLI_freelinkN(&anim_basepaths, ld);
723                 }
724         }
725
726         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
727         if (!make_copy)
728                 ngroup->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
729
730         return 1;
731 }
732
733 typedef enum eNodeGroupSeparateType {
734         NODE_GS_COPY,
735         NODE_GS_MOVE
736 } eNodeGroupSeparateType;
737
738 /* Operator Property */
739 EnumPropertyItem node_group_separate_types[] = {
740         {NODE_GS_COPY, "COPY", 0, "Copy", "Copy to parent node tree, keep group intact"},
741         {NODE_GS_MOVE, "MOVE", 0, "Move", "Move to parent node tree, remove from group"},
742         {0, NULL, 0, NULL, NULL}
743 };
744
745 static int node_group_separate_exec(bContext *C, wmOperator *op)
746 {
747         SpaceNode *snode = CTX_wm_space_node(C);
748         bNode *gnode;
749         int type = RNA_enum_get(op->ptr, "type");
750
751         ED_preview_kill_jobs(C);
752
753         /* are we inside of a group? */
754         gnode = node_tree_get_editgroup(snode->nodetree);
755         if (!gnode) {
756                 BKE_report(op->reports, RPT_WARNING, "Not inside node group");
757                 return OPERATOR_CANCELLED;
758         }
759
760         switch (type) {
761                 case NODE_GS_COPY:
762                         if (!node_group_separate_selected(snode->nodetree, gnode, 1)) {
763                                 BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes");
764                                 return OPERATOR_CANCELLED;
765                         }
766                         break;
767                 case NODE_GS_MOVE:
768                         if (!node_group_separate_selected(snode->nodetree, gnode, 0)) {
769                                 BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes");
770                                 return OPERATOR_CANCELLED;
771                         }
772                         break;
773         }
774
775         /* switch to parent tree */
776         snode_make_group_editable(snode, NULL);
777
778         ntreeUpdateTree(snode->nodetree);
779
780         snode_notify(C, snode);
781         snode_dag_update(C, snode);
782
783         return OPERATOR_FINISHED;
784 }
785
786 static int node_group_separate_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *UNUSED(event))
787 {
788         uiPopupMenu *pup = uiPupMenuBegin(C, "Separate", ICON_NONE);
789         uiLayout *layout = uiPupMenuLayout(pup);
790
791         uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
792         uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_COPY);
793         uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_MOVE);
794
795         uiPupMenuEnd(C, pup);
796
797         return OPERATOR_CANCELLED;
798 }
799
800 void NODE_OT_group_separate(wmOperatorType *ot)
801 {
802         /* identifiers */
803         ot->name = "Separate";
804         ot->description = "Separate selected nodes from the node group";
805         ot->idname = "NODE_OT_group_separate";
806
807         /* api callbacks */
808         ot->invoke = node_group_separate_invoke;
809         ot->exec = node_group_separate_exec;
810         ot->poll = ED_operator_node_active;
811
812         /* flags */
813         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
814
815         RNA_def_enum(ot->srna, "type", node_group_separate_types, NODE_GS_COPY, "Type", "");
816 }
817
818 /* ****************** Make Group operator ******************* */
819
820 static int node_group_make_test(bNodeTree *ntree, bNode *gnode)
821 {
822         bNode *node;
823         bNodeLink *link;
824         int totnode = 0;
825
826         /* is there something to group? also do some clearing */
827         for (node = ntree->nodes.first; node; node = node->next) {
828                 if (node == gnode)
829                         continue;
830
831                 if (node->flag & NODE_SELECT) {
832                         /* no groups in groups */
833                         if (node->type == NODE_GROUP)
834                                 return 0;
835                         totnode++;
836                 }
837
838                 node->done = 0;
839         }
840         if (totnode == 0) return 0;
841
842         /* check if all connections are OK, no unselected node has both
843          * inputs and outputs to a selection */
844         for (link = ntree->links.first; link; link = link->next) {
845                 if (link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT && link->fromnode != gnode)
846                         link->tonode->done |= 1;
847                 if (link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT && link->tonode != gnode)
848                         link->fromnode->done |= 2;
849         }
850
851         for (node = ntree->nodes.first; node; node = node->next) {
852                 if (node == gnode)
853                         continue;
854                 if ((node->flag & NODE_SELECT) == 0)
855                         if (node->done == 3)
856                                 break;
857         }
858         if (node)
859                 return 0;
860
861         return 1;
862 }
863
864
865 static void node_get_selected_minmax(bNodeTree *ntree, bNode *gnode, float *min, float *max)
866 {
867         bNode *node;
868         INIT_MINMAX2(min, max);
869         for (node = ntree->nodes.first; node; node = node->next) {
870                 if (node == gnode)
871                         continue;
872                 if (node->flag & NODE_SELECT) {
873                         minmax_v2v2_v2(min, max, &node->locx);
874                 }
875         }
876 }
877
878 static int node_group_make_insert_selected(bNodeTree *ntree, bNode *gnode)
879 {
880         bNodeTree *ngroup = (bNodeTree *)gnode->id;
881         bNodeLink *link, *linkn;
882         bNode *node, *nextn;
883         bNodeSocket *gsock, *sock;
884         ListBase anim_basepaths = {NULL, NULL};
885         float min[2], max[2];
886
887         /* deselect all nodes in the target tree */
888         for (node = ngroup->nodes.first; node; node = node->next)
889                 node_deselect(node);
890
891         node_get_selected_minmax(ntree, gnode, min, max);
892
893         /* move nodes over */
894         for (node = ntree->nodes.first; node; node = nextn) {
895                 nextn = node->next;
896                 if (node == gnode)
897                         continue;
898                 if (node->flag & NODE_SELECT) {
899                         /* keep track of this node's RNA "base" path (the part of the pat identifying the node)
900                          * if the old nodetree has animation data which potentially covers this node
901                          */
902                         if (ntree->adt) {
903                                 PointerRNA ptr;
904                                 char *path;
905
906                                 RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
907                                 path = RNA_path_from_ID_to_struct(&ptr);
908
909                                 if (path)
910                                         BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
911                         }
912
913                         /* ensure valid parent pointers, detach if parent stays outside the group */
914                         if (node->parent && !(node->parent->flag & NODE_SELECT))
915                                 nodeDetachNode(node);
916
917                         /* change node-collection membership */
918                         BLI_remlink(&ntree->nodes, node);
919                         BLI_addtail(&ngroup->nodes, node);
920
921                         /* ensure unique node name in the ngroup */
922                         nodeUniqueName(ngroup, node);
923
924                         node->locx -= 0.5f * (min[0] + max[0]);
925                         node->locy -= 0.5f * (min[1] + max[1]);
926                 }
927                 else {
928                         /* if the parent is to be inserted but not the child, detach properly */
929                         if (node->parent && (node->parent->flag & NODE_SELECT))
930                                 nodeDetachNode(node);
931                 }
932         }
933
934         /* move animation data over */
935         if (ntree->adt) {
936                 LinkData *ld, *ldn = NULL;
937
938                 BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
939
940                 /* paths + their wrappers need to be freed */
941                 for (ld = anim_basepaths.first; ld; ld = ldn) {
942                         ldn = ld->next;
943
944                         MEM_freeN(ld->data);
945                         BLI_freelinkN(&anim_basepaths, ld);
946                 }
947         }
948
949         /* node groups don't use internal cached data */
950         ntreeFreeCache(ngroup);
951
952         /* relink external sockets */
953         for (link = ntree->links.first; link; link = linkn) {
954                 int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT) && link->fromnode != gnode);
955                 int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT) && link->tonode != gnode);
956                 linkn = link->next;
957
958                 if ((fromselect && link->tonode == gnode) || (toselect && link->fromnode == gnode)) {
959                         /* remove all links to/from the gnode.
960                          * this can remove link information, but there's no general way to preserve it.
961                          */
962                         nodeRemLink(ntree, link);
963                 }
964                 else if (fromselect && toselect) {
965                         BLI_remlink(&ntree->links, link);
966                         BLI_addtail(&ngroup->links, link);
967                 }
968                 else if (toselect) {
969                         gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
970                         link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
971                         link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
972                         link->tonode = gnode;
973                 }
974                 else if (fromselect) {
975                         /* search for existing group node socket */
976                         for (gsock = ngroup->outputs.first; gsock; gsock = gsock->next)
977                                 if (gsock->link && gsock->link->fromsock == link->fromsock)
978                                         break;
979                         if (!gsock) {
980                                 gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
981                                 gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
982                                 link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
983                         }
984                         else
985                                 link->fromsock = node_group_find_output(gnode, gsock);
986                         link->fromnode = gnode;
987                 }
988         }
989
990         /* auto-add interface for "solo" nodes */
991         node = ((bNodeTree *)gnode->id)->nodes.first;
992         if (node && !node->next) {
993                 for (sock = node->inputs.first; sock; sock = sock->next) {
994                         int skip = FALSE;
995                         
996                         for (link = ((bNodeTree *)gnode->id)->links.first; link; link = link->next)
997                                 if (link->tosock == sock)
998                                         skip = TRUE;
999
1000                         if (skip == TRUE)
1001                                 continue;
1002
1003                         gsock = node_group_expose_socket(ngroup, sock, SOCK_IN);
1004                         node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
1005                         nodeAddLink(ngroup, NULL, gsock, node, sock);
1006                 }
1007
1008                 for (sock = node->outputs.first; sock; sock = sock->next) {
1009                         int skip = FALSE;
1010                         
1011                         for (link = ((bNodeTree *)gnode->id)->links.first; link; link = link->next)
1012                                 if (link->fromsock == sock)
1013                                         skip = TRUE;
1014
1015                         if (skip == TRUE)
1016                                 continue;
1017
1018                         gsock = node_group_expose_socket(ngroup, sock, SOCK_OUT);
1019                         node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
1020                         nodeAddLink(ngroup, NULL, gsock, node, sock);
1021                 }
1022         }
1023
1024         /* update of the group tree */
1025         ngroup->update |= NTREE_UPDATE | NTREE_UPDATE_LINKS;
1026         /* update of the tree containing the group instance node */
1027         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
1028
1029         return 1;
1030 }
1031
1032 static bNode *node_group_make_from_selected(bNodeTree *ntree)
1033 {
1034         bNode *gnode;
1035         bNodeTree *ngroup;
1036         float min[2], max[2];
1037         bNodeTemplate ntemp;
1038
1039         node_get_selected_minmax(ntree, NULL, min, max);
1040
1041         /* new nodetree */
1042         ngroup = ntreeAddTree(G.main, "NodeGroup", ntree->type, NODE_GROUP);
1043
1044         /* make group node */
1045         ntemp.type = NODE_GROUP;
1046         ntemp.ngroup = ngroup;
1047         gnode = nodeAddNode(ntree, &ntemp);
1048         gnode->locx = 0.5f * (min[0] + max[0]);
1049         gnode->locy = 0.5f * (min[1] + max[1]);
1050
1051         node_group_make_insert_selected(ntree, gnode);
1052
1053         /* update of the tree containing the group instance node */
1054         ntree->update |= NTREE_UPDATE_NODES;
1055
1056         return gnode;
1057 }
1058
1059 typedef enum eNodeGroupMakeType {
1060         NODE_GM_NEW,
1061         NODE_GM_INSERT
1062 } eNodeGroupMakeType;
1063
1064 /* Operator Property */
1065 EnumPropertyItem node_group_make_types[] = {
1066         {NODE_GM_NEW, "NEW", 0, "New", "Create a new node group from selected nodes"},
1067         {NODE_GM_INSERT, "INSERT", 0, "Insert", "Insert into active node group"},
1068         {0, NULL, 0, NULL, NULL}
1069 };
1070
1071 static int node_group_make_exec(bContext *C, wmOperator *op)
1072 {
1073         SpaceNode *snode = CTX_wm_space_node(C);
1074         bNode *gnode;
1075         int type = RNA_enum_get(op->ptr, "type");
1076
1077         if (snode->edittree != snode->nodetree) {
1078                 BKE_report(op->reports, RPT_WARNING, "Cannot add a new group in a group");
1079                 return OPERATOR_CANCELLED;
1080         }
1081
1082         /* for time being... is too complex to handle */
1083         if (snode->treetype == NTREE_COMPOSIT) {
1084                 for (gnode = snode->nodetree->nodes.first; gnode; gnode = gnode->next) {
1085                         if (gnode->flag & SELECT)
1086                                 if (gnode->type == CMP_NODE_R_LAYERS)
1087                                         break;
1088                 }
1089
1090                 if (gnode) {
1091                         BKE_report(op->reports, RPT_WARNING, "Cannot add a Render Layers node in a group");
1092                         return OPERATOR_CANCELLED;
1093                 }
1094         }
1095
1096         ED_preview_kill_jobs(C);
1097
1098         switch (type) {
1099                 case NODE_GM_NEW:
1100                         if (node_group_make_test(snode->nodetree, NULL)) {
1101                                 gnode = node_group_make_from_selected(snode->nodetree);
1102                         }
1103                         else {
1104                                 BKE_report(op->reports, RPT_WARNING, "Cannot make group");
1105                                 return OPERATOR_CANCELLED;
1106                         }
1107                         break;
1108                 case NODE_GM_INSERT:
1109                         gnode = nodeGetActive(snode->nodetree);
1110                         if (!gnode || gnode->type != NODE_GROUP) {
1111                                 BKE_report(op->reports, RPT_WARNING, "No active group node");
1112                                 return OPERATOR_CANCELLED;
1113                         }
1114                         if (node_group_make_test(snode->nodetree, gnode)) {
1115                                 node_group_make_insert_selected(snode->nodetree, gnode);
1116                         }
1117                         else {
1118                                 BKE_report(op->reports, RPT_WARNING, "Cannot insert into group");
1119                                 return OPERATOR_CANCELLED;
1120                         }
1121                         break;
1122         }
1123
1124         if (gnode) {
1125                 nodeSetActive(snode->nodetree, gnode);
1126                 snode_make_group_editable(snode, gnode);
1127         }
1128
1129         if (gnode)
1130                 ntreeUpdateTree((bNodeTree *)gnode->id);
1131         ntreeUpdateTree(snode->nodetree);
1132
1133         snode_notify(C, snode);
1134         snode_dag_update(C, snode);
1135
1136         return OPERATOR_FINISHED;
1137 }
1138
1139 static int node_group_make_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *UNUSED(event))
1140 {
1141         SpaceNode *snode = CTX_wm_space_node(C);
1142         bNode *act = nodeGetActive(snode->edittree);
1143         uiPopupMenu *pup = uiPupMenuBegin(C, "Make Group", ICON_NONE);
1144         uiLayout *layout = uiPupMenuLayout(pup);
1145
1146         uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
1147         uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_NEW);
1148
1149         /* if active node is a group, add insert option */
1150         if (act && act->type == NODE_GROUP) {
1151                 uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_INSERT);
1152         }
1153
1154         uiPupMenuEnd(C, pup);
1155
1156         return OPERATOR_CANCELLED;
1157 }
1158
1159 void NODE_OT_group_make(wmOperatorType *ot)
1160 {
1161         /* identifiers */
1162         ot->name = "Group";
1163         ot->description = "Make group from selected nodes";
1164         ot->idname = "NODE_OT_group_make";
1165
1166         /* api callbacks */
1167         ot->invoke = node_group_make_invoke;
1168         ot->exec = node_group_make_exec;
1169         ot->poll = ED_operator_node_active;
1170
1171         /* flags */
1172         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1173
1174         RNA_def_enum(ot->srna, "type", node_group_make_types, NODE_GM_NEW, "Type", "");
1175 }