fix for node editor re-rendering when the background image was moved in the view.
[blender.git] / source / blender / editors / space_node / node_edit.c
index fe734e53651cf0c514766ba3cc2452c0535dcbde..6fc33a8baad5ef7b6ea5500714f4f0c800ccc045 100644 (file)
 #include "DNA_particle_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_world_types.h"
+#include "DNA_action_types.h"
+#include "DNA_anim_types.h"
 
 #include "BLI_math.h"
 #include "BLI_blenlib.h"
 #include "BLI_utildefines.h"
 
+#include "BKE_action.h"
+#include "BKE_animsys.h"
 #include "BKE_context.h"
 #include "BKE_depsgraph.h"
 #include "BKE_global.h"
@@ -94,6 +98,7 @@
 #include "GPU_material.h"
 
 #include "node_intern.h"
+#include "NOD_socket.h"
 
 static EnumPropertyItem socket_in_out_items[] = {
        { SOCK_IN, "SOCK_IN", 0, "Input", "" },
@@ -115,7 +120,7 @@ typedef struct CompoJob {
 /* called by compo, only to check job 'stop' value */
 static int compo_breakjob(void *cjv)
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
        
        return *(cj->stop);
 }
@@ -123,41 +128,41 @@ static int compo_breakjob(void *cjv)
 /* called by compo, wmJob sends notifier */
 static void compo_redrawjob(void *cjv, char *UNUSED(str))
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
        
-       *(cj->do_update)= 1;
+       *(cj->do_update) = TRUE;
 }
 
 static void compo_freejob(void *cjv)
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
 
-       if(cj->localtree) {
+       if (cj->localtree) {
                ntreeLocalMerge(cj->localtree, cj->ntree);
        }
        MEM_freeN(cj);
 }
 
 /* only now we copy the nodetree, so adding many jobs while
  sliding buttons doesn't frustrate */
* sliding buttons doesn't frustrate */
 static void compo_initjob(void *cjv)
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
 
-       cj->localtree= ntreeLocalize(cj->ntree);
+       cj->localtree = ntreeLocalize(cj->ntree);
 }
 
 /* called before redraw notifiers, it moves finished previews over */
 static void compo_updatejob(void *cjv)
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
        
        ntreeLocalSync(cj->localtree, cj->ntree);
 }
 
 static void compo_progressjob(void *cjv, float progress)
 {
-       CompoJob *cj= cjv;
+       CompoJob *cj = cjv;
        
        *(cj->progress) = progress;
 }
@@ -166,49 +171,49 @@ static void compo_progressjob(void *cjv, float progress)
 /* only this runs inside thread */
 static void compo_startjob(void *cjv, short *stop, short *do_update, float *progress)
 {
-       CompoJob *cj= cjv;
-       bNodeTree *ntree= cj->localtree;
+       CompoJob *cj = cjv;
+       bNodeTree *ntree = cj->localtree;
 
-       if(cj->scene->use_nodes==0)
+       if (cj->scene->use_nodes == FALSE)
                return;
        
-       cj->stop= stop;
-       cj->do_update= do_update;
-       cj->progress= progress;
-       
-       ntree->test_break= compo_breakjob;
-       ntree->tbh= cj;
-       ntree->stats_draw= compo_redrawjob;
-       ntree->sdh= cj;
-       ntree->progress= compo_progressjob;
-       ntree->prh= cj;
+       cj->stop = stop;
+       cj->do_update = do_update;
+       cj->progress = progress;
+
+       ntree->test_break = compo_breakjob;
+       ntree->tbh = cj;
+       ntree->stats_draw = compo_redrawjob;
+       ntree->sdh = cj;
+       ntree->progress = compo_progressjob;
+       ntree->prh = cj;
        
        // XXX BIF_store_spare();
        
-       ntreeCompositExecTree(ntree, &cj->scene->r, 1); /* 1 is do_previews */
-       
-       ntree->test_break= NULL;
-       ntree->stats_draw= NULL;
-       ntree->progress= NULL;
+       ntreeCompositExecTree(ntree, &cj->scene->r, 0, 1);  /* 1 is do_previews */
+
+       ntree->test_break = NULL;
+       ntree->stats_draw = NULL;
+       ntree->progress = NULL;
 
 }
 
 void snode_composite_job(const bContext *C, ScrArea *sa)
 {
-       SpaceNode *snode= sa->spacedata.first;
+       SpaceNode *snode = sa->spacedata.first;
        wmJob *steve;
        CompoJob *cj;
 
-       steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Compositing", WM_JOB_EXCL_RENDER|WM_JOB_PROGRESS);
-       cj= MEM_callocN(sizeof(CompoJob), "compo job");
+       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Compositing", WM_JOB_EXCL_RENDER | WM_JOB_PROGRESS);
+       cj = MEM_callocN(sizeof(CompoJob), "compo job");
        
        /* customdata for preview thread */
-       cj->scene= CTX_data_scene(C);
-       cj->ntree= snode->nodetree;
+       cj->scene = CTX_data_scene(C);
+       cj->ntree = snode->nodetree;
        
        /* setup job */
        WM_jobs_customdata(steve, cj, compo_freejob);
-       WM_jobs_timer(steve, 0.1, NC_SCENE, NC_SCENE|ND_COMPO_RESULT);
+       WM_jobs_timer(steve, 0.1, NC_SCENE, NC_SCENE | ND_COMPO_RESULT);
        WM_jobs_callbacks(steve, compo_startjob, compo_initjob, compo_updatejob, NULL);
        
        WM_jobs_start(CTX_wm_manager(C), steve);
@@ -220,9 +225,9 @@ void snode_composite_job(const bContext *C, ScrArea *sa)
 /* operator poll callback */
 static int composite_node_active(bContext *C)
 {
-       ifED_operator_node_active(C)) {
-               SpaceNode *snode= CTX_wm_space_node(C);
-               if(snode->treetype==NTREE_COMPOSIT)
+       if (ED_operator_node_active(C)) {
+               SpaceNode *snode = CTX_wm_space_node(C);
+               if (snode->treetype == NTREE_COMPOSIT)
                        return 1;
        }
        return 0;
@@ -234,30 +239,59 @@ static bNode *editnode_get_active(bNodeTree *ntree)
        bNode *node;
        
        /* check for edited group */
-       for(node= ntree->nodes.first; node; node= node->next)
-               if(nodeGroupEditGet(node))
+       for (node = ntree->nodes.first; node; node = node->next)
+               if (nodeGroupEditGet(node))
                        break;
-       if(node)
+       if (node)
                return nodeGetActive((bNodeTree *)node->id);
        else
                return nodeGetActive(ntree);
 }
 
-void snode_dag_update(bContext *UNUSED(C), SpaceNode *snode)
+static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup)
+{
+       bNode *node;
+       
+       if (ntree == lookup)
+               return 1;
+       
+       for (node = ntree->nodes.first; node; node = node->next)
+               if (node->type == NODE_GROUP && node->id)
+                       if (has_nodetree((bNodeTree *)node->id, lookup))
+                               return 1;
+       
+       return 0;
+}
+
+static void snode_dag_update_group(void *calldata, ID *owner_id, bNodeTree *ntree)
 {
+       if (has_nodetree(ntree, calldata))
+               DAG_id_tag_update(owner_id, 0);
+}
+
+void snode_dag_update(bContext *C, SpaceNode *snode)
+{
+       Main *bmain = CTX_data_main(C);
+
+       /* for groups, update all ID's using this */
+       if (snode->edittree != snode->nodetree) {
+               bNodeTreeType *tti = ntreeGetType(snode->edittree->type);
+               tti->foreach_nodetree(bmain, snode->edittree, snode_dag_update_group);
+       }
+
        DAG_id_tag_update(snode->id, 0);
 }
 
 void snode_notify(bContext *C, SpaceNode *snode)
 {
-       WM_event_add_notifier(C, NC_NODE|NA_EDITED, NULL);
-
-       if(snode->treetype==NTREE_SHADER)
-               WM_event_add_notifier(C, NC_MATERIAL|ND_NODES, snode->id);
-       else if(snode->treetype==NTREE_COMPOSIT)
-               WM_event_add_notifier(C, NC_SCENE|ND_NODES, snode->id);
-       else if(snode->treetype==NTREE_TEXTURE)
-               WM_event_add_notifier(C, NC_TEXTURE|ND_NODES, snode->id);
+       WM_event_add_notifier(C, NC_NODE | NA_EDITED, NULL);
+
+       if (snode->treetype == NTREE_SHADER)
+               WM_event_add_notifier(C, NC_MATERIAL | ND_NODES, snode->id);
+       else if (snode->treetype == NTREE_COMPOSIT)
+               WM_event_add_notifier(C, NC_SCENE | ND_NODES, snode->id);
+       else if (snode->treetype == NTREE_TEXTURE)
+               WM_event_add_notifier(C, NC_TEXTURE | ND_NODES, snode->id);
 }
 
 bNode *node_tree_get_editgroup(bNodeTree *nodetree)
@@ -265,8 +299,8 @@ bNode *node_tree_get_editgroup(bNodeTree *nodetree)
        bNode *gnode;
        
        /* get the groupnode */
-       for(gnode= nodetree->nodes.first; gnode; gnode= gnode->next)
-               if(nodeGroupEditGet(gnode))
+       for (gnode = nodetree->nodes.first; gnode; gnode = gnode->next)
+               if (nodeGroupEditGet(gnode))
                        break;
        return gnode;
 }
@@ -282,14 +316,14 @@ void ED_node_shader_default(Scene *scene, ID *id)
        int output_type, shader_type;
        float color[3], strength = 1.0f;
        
-       ntree= ntreeAddTree("Shader Nodetree", NTREE_SHADER, 0);
+       ntree = ntreeAddTree("Shader Nodetree", NTREE_SHADER, 0);
 
-       switch(GS(id->name)) {
+       switch (GS(id->name)) {
                case ID_MA: {
-                       Material *ma= (Material*)id;
+                       Material *ma = (Material *)id;
                        ma->nodetree = ntree;
 
-                       if(scene_use_new_shading_nodes(scene)) {
+                       if (BKE_scene_use_new_shading_nodes(scene)) {
                                output_type = SH_NODE_OUTPUT_MATERIAL;
                                shader_type = SH_NODE_BSDF_DIFFUSE;
                        }
@@ -299,32 +333,32 @@ void ED_node_shader_default(Scene *scene, ID *id)
                        }
 
                        copy_v3_v3(color, &ma->r);
-                       strength= 0.0f;
+                       strength = 0.0f;
                        break;
                }
                case ID_WO: {
-                       World *wo= (World*)id;
+                       World *wo = (World *)id;
                        wo->nodetree = ntree;
 
                        output_type = SH_NODE_OUTPUT_WORLD;
                        shader_type = SH_NODE_BACKGROUND;
 
                        copy_v3_v3(color, &wo->horr);
-                       strength= 1.0f;
+                       strength = 1.0f;
                        break;
                }
                case ID_LA: {
-                       Lamp *la= (Lamp*)id;
+                       Lamp *la = (Lamp *)id;
                        la->nodetree = ntree;
 
                        output_type = SH_NODE_OUTPUT_LAMP;
                        shader_type = SH_NODE_EMISSION;
 
                        copy_v3_v3(color, &la->r);
-                       if(la->type == LA_LOCAL || la->type == LA_SPOT || la->type == LA_AREA)
-                               strength= 100.0f;
+                       if (la->type == LA_LOCAL || la->type == LA_SPOT || la->type == LA_AREA)
+                               strength = 100.0f;
                        else
-                               strength= 1.0f;
+                               strength = 1.0f;
                        break;
                }
                default:
@@ -333,27 +367,27 @@ void ED_node_shader_default(Scene *scene, ID *id)
        }
        
        ntemp.type = output_type;
-       out= nodeAddNode(ntree, &ntemp);
-       out->locx= 300.0f; out->locy= 300.0f;
+       out = nodeAddNode(ntree, &ntemp);
+       out->locx = 300.0f; out->locy = 300.0f;
        
        ntemp.type = shader_type;
-       in= nodeAddNode(ntree, &ntemp);
-       in->locx= 10.0f; in->locy= 300.0f;
+       in = nodeAddNode(ntree, &ntemp);
+       in->locx = 10.0f; in->locy = 300.0f;
        nodeSetActive(ntree, in);
        
        /* only a link from color to color */
-       fromsock= in->outputs.first;
-       tosock= out->inputs.first;
+       fromsock = in->outputs.first;
+       tosock = out->inputs.first;
        nodeAddLink(ntree, in, fromsock, out, tosock);
 
        /* default values */
-       if(scene_use_new_shading_nodes(scene)) {
-               sock= in->inputs.first;
-               copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, color);
+       if (BKE_scene_use_new_shading_nodes(scene)) {
+               sock = in->inputs.first;
+               copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, color);
 
-               if(strength != 0.0f) {
-                       sock= in->inputs.last;
-                       ((bNodeSocketValueFloat*)sock->default_value)->value= strength;
+               if (strength != 0.0f) {
+                       sock = in->inputs.last;
+                       ((bNodeSocketValueFloat *)sock->default_value)->value = strength;
                }
        }
        
@@ -369,30 +403,34 @@ void ED_node_composit_default(Scene *sce)
        bNodeTemplate ntemp;
        
        /* but lets check it anyway */
-       if(sce->nodetree) {
-               if (G.f & G_DEBUG)
+       if (sce->nodetree) {
+               if (G.debug & G_DEBUG)
                        printf("error in composite initialize\n");
                return;
        }
        
-       sce->nodetree= ntreeAddTree("Compositing Nodetree", NTREE_COMPOSIT, 0);
+       sce->nodetree = ntreeAddTree("Compositing Nodetree", NTREE_COMPOSIT, 0);
+
+       sce->nodetree->chunksize = 256;
+       sce->nodetree->edit_quality = NTREE_QUALITY_HIGH;
+       sce->nodetree->render_quality = NTREE_QUALITY_HIGH;
        
        ntemp.type = CMP_NODE_COMPOSITE;
-       out= nodeAddNode(sce->nodetree, &ntemp);
-       out->locx= 300.0f; out->locy= 400.0f;
-       out->id= &sce->id;
+       out = nodeAddNode(sce->nodetree, &ntemp);
+       out->locx = 300.0f; out->locy = 400.0f;
+       out->id = &sce->id;
        id_us_plus(out->id);
        
        ntemp.type = CMP_NODE_R_LAYERS;
-       in= nodeAddNode(sce->nodetree, &ntemp);
-       in->locx= 10.0f; in->locy= 400.0f;
-       in->id= &sce->id;
+       in = nodeAddNode(sce->nodetree, &ntemp);
+       in->locx = 10.0f; in->locy = 400.0f;
+       in->id = &sce->id;
        id_us_plus(in->id);
        nodeSetActive(sce->nodetree, in);
        
        /* links from color to color */
-       fromsock= in->outputs.first;
-       tosock= out->inputs.first;
+       fromsock = in->outputs.first;
+       tosock = out->inputs.first;
        nodeAddLink(sce->nodetree, in, fromsock, out, tosock);
        
        ntreeUpdateTree(sce->nodetree);
@@ -409,25 +447,25 @@ void ED_node_texture_default(Tex *tx)
        bNodeTemplate ntemp;
        
        /* but lets check it anyway */
-       if(tx->nodetree) {
-               if (G.f & G_DEBUG)
+       if (tx->nodetree) {
+               if (G.debug & G_DEBUG)
                        printf("error in texture initialize\n");
                return;
        }
        
-       tx->nodetree= ntreeAddTree("Texture Nodetree", NTREE_TEXTURE, 0);
+       tx->nodetree = ntreeAddTree("Texture Nodetree", NTREE_TEXTURE, 0);
        
        ntemp.type = TEX_NODE_OUTPUT;
-       out= nodeAddNode(tx->nodetree, &ntemp);
-       out->locx= 300.0f; out->locy= 300.0f;
+       out = nodeAddNode(tx->nodetree, &ntemp);
+       out->locx = 300.0f; out->locy = 300.0f;
        
        ntemp.type = TEX_NODE_CHECKER;
-       in= nodeAddNode(tx->nodetree, &ntemp);
-       in->locx= 10.0f; in->locy= 300.0f;
+       in = nodeAddNode(tx->nodetree, &ntemp);
+       in->locx = 10.0f; in->locy = 300.0f;
        nodeSetActive(tx->nodetree, in);
        
-       fromsock= in->outputs.first;
-       tosock= out->inputs.first;
+       fromsock = in->outputs.first;
+       tosock = out->inputs.first;
        nodeAddLink(tx->nodetree, in, fromsock, out, tosock);
        
        ntreeUpdateTree(tx->nodetree);
@@ -437,128 +475,128 @@ void ED_node_texture_default(Tex *tx)
 void node_tree_from_ID(ID *id, bNodeTree **ntree, bNodeTree **edittree, int *treetype)
 {
        if (id) {
-               bNode *node= NULL;
-               short idtype= GS(id->name);
+               bNode *node = NULL;
+               short idtype = GS(id->name);
        
-               if(idtype == ID_NT) {
-                       *ntree= (bNodeTree*)id;
-                       if(treetype) *treetype= (*ntree)->type;
+               if (idtype == ID_NT) {
+                       *ntree = (bNodeTree *)id;
+                       if (treetype) *treetype = (*ntree)->type;
                }
-               else if(idtype == ID_MA) {
-                       *ntree= ((Material*)id)->nodetree;
-                       if(treetype) *treetype= NTREE_SHADER;
+               else if (idtype == ID_MA) {
+                       *ntree = ((Material *)id)->nodetree;
+                       if (treetype) *treetype = NTREE_SHADER;
                }
-               else if(idtype == ID_LA) {
-                       *ntree= ((Lamp*)id)->nodetree;
-                       if(treetype) *treetype= NTREE_SHADER;
+               else if (idtype == ID_LA) {
+                       *ntree = ((Lamp *)id)->nodetree;
+                       if (treetype) *treetype = NTREE_SHADER;
                }
-               else if(idtype == ID_WO) {
-                       *ntree= ((World*)id)->nodetree;
-                       if(treetype) *treetype= NTREE_SHADER;
+               else if (idtype == ID_WO) {
+                       *ntree = ((World *)id)->nodetree;
+                       if (treetype) *treetype = NTREE_SHADER;
                }
-               else if(idtype == ID_SCE) {
-                       *ntree= ((Scene*)id)->nodetree;
-                       if(treetype) *treetype= NTREE_COMPOSIT;
+               else if (idtype == ID_SCE) {
+                       *ntree = ((Scene *)id)->nodetree;
+                       if (treetype) *treetype = NTREE_COMPOSIT;
                }
-               else if(idtype == ID_TE) {
-                       *ntree= ((Tex*)id)->nodetree;
-                       if(treetype) *treetype= NTREE_TEXTURE;
+               else if (idtype == ID_TE) {
+                       *ntree = ((Tex *)id)->nodetree;
+                       if (treetype) *treetype = NTREE_TEXTURE;
                }
                else {
-                       if(treetype) *treetype= 0;
+                       if (treetype) *treetype = 0;
                        return;
                }
        
                /* find editable group */
-               if(edittree) {
-                       if(*ntree)
-                               for(node= (*ntree)->nodes.first; node; node= node->next)
-                                       if(nodeGroupEditGet(node))
+               if (edittree) {
+                       if (*ntree)
+                               for (node = (*ntree)->nodes.first; node; node = node->next)
+                                       if (nodeGroupEditGet(node))
                                                break;
                        
-                       if(node && node->id)
-                               *edittree= (bNodeTree *)node->id;
+                       if (node && node->id)
+                               *edittree = (bNodeTree *)node->id;
                        else
-                               *edittree= *ntree;
+                               *edittree = *ntree;
                }
        }
        else {
-               *ntree= NULL;
-               *edittree= NULL;
-               if(treetype) *treetype= 0;
+               *ntree = NULL;
+               *edittree = NULL;
+               if (treetype) *treetype = 0;
        }
 }
 
 /* Here we set the active tree(s), even called for each redraw now, so keep it fast :) */
 void snode_set_context(SpaceNode *snode, Scene *scene)
 {
-       Object *ob= OBACT;
+       Object *ob = OBACT;
        
-       snode->id= snode->from= NULL;
+       snode->id = snode->from = NULL;
        
-       if(snode->treetype==NTREE_SHADER) {
+       if (snode->treetype == NTREE_SHADER) {
                /* need active object, or we allow pinning... */
-               if(snode->shaderfrom == SNODE_SHADER_OBJECT) {
-                       if(ob) {
-                               if(ob->type == OB_LAMP) {
-                                       snode->from= &ob->id;
-                                       snode->id= ob->data;
+               if (snode->shaderfrom == SNODE_SHADER_OBJECT) {
+                       if (ob) {
+                               if (ob->type == OB_LAMP) {
+                                       snode->from = &ob->id;
+                                       snode->id = ob->data;
                                }
                                else {
-                                       Material *ma= give_current_material(ob, ob->actcol);
-                                       if(ma) {
-                                               snode->from= &ob->id;
-                                               snode->id= &ma->id;
+                                       Material *ma = give_current_material(ob, ob->actcol);
+                                       if (ma) {
+                                               snode->from = &ob->id;
+                                               snode->id = &ma->id;
                                        }
                                }
                        }
                }
                else { /* SNODE_SHADER_WORLD */
-                       if(scene->world) {
-                               snode->from= NULL;
-                               snode->id= &scene->world->id;
+                       if (scene->world) {
+                               snode->from = NULL;
+                               snode->id = &scene->world->id;
                        }
                }
        }
-       else if(snode->treetype==NTREE_COMPOSIT) {
-               snode->id= &scene->id;
+       else if (snode->treetype == NTREE_COMPOSIT) {
+               snode->id = &scene->id;
                
                /* update output sockets based on available layers */
                ntreeCompositForceHidden(scene->nodetree, scene);
        }
-       else if(snode->treetype==NTREE_TEXTURE) {
-               Tex *tx= NULL;
+       else if (snode->treetype == NTREE_TEXTURE) {
+               Tex *tx = NULL;
 
-               if(snode->texfrom==SNODE_TEX_OBJECT) {
-                       if(ob) {
-                               tx= give_current_object_texture(ob);
+               if (snode->texfrom == SNODE_TEX_OBJECT) {
+                       if (ob) {
+                               tx = give_current_object_texture(ob);
 
-                               if(ob->type == OB_LAMP)
-                                       snode->from= (ID*)ob->data;
+                               if (ob->type == OB_LAMP)
+                                       snode->from = (ID *)ob->data;
                                else
-                                       snode->from= (ID*)give_current_material(ob, ob->actcol);
+                                       snode->from = (ID *)give_current_material(ob, ob->actcol);
 
                                /* from is not set fully for material nodes, should be ID + Node then */
-                               snode->id= &tx->id;
+                               snode->id = &tx->id;
                        }
                }
-               else if(snode->texfrom==SNODE_TEX_WORLD) {
-                       tx= give_current_world_texture(scene->world);
-                       snode->from= (ID *)scene->world;
-                       snode->id= &tx->id;
+               else if (snode->texfrom == SNODE_TEX_WORLD) {
+                       tx = give_current_world_texture(scene->world);
+                       snode->from = (ID *)scene->world;
+                       snode->id = &tx->id;
                }
                else {
-                       struct Brush *brush= NULL;
+                       struct Brush *brush = NULL;
                        
-                       if(ob && (ob->mode & OB_MODE_SCULPT))
-                               brush= paint_brush(&scene->toolsettings->sculpt->paint);
+                       if (ob && (ob->mode & OB_MODE_SCULPT))
+                               brush = paint_brush(&scene->toolsettings->sculpt->paint);
                        else
-                               brush= paint_brush(&scene->toolsettings->imapaint.paint);
+                               brush = paint_brush(&scene->toolsettings->imapaint.paint);
 
                        if (brush) {
-                               snode->from= (ID *)brush;
-                               tx= give_current_brush_texture(brush);
-                               snode->id= &tx->id;
+                               snode->from = (ID *)brush;
+                               tx = give_current_brush_texture(brush);
+                               snode->id = &tx->id;
                        }
                }
        }
@@ -580,98 +618,85 @@ static void snode_update(SpaceNode *snode, bNode *node)
                nodeUpdate(snode->edittree, node);
        
        /* if inside group, tag entire group */
-       gnode= node_tree_get_editgroup(snode->nodetree);
-       if(gnode)
+       gnode = node_tree_get_editgroup(snode->nodetree);
+       if (gnode)
                nodeUpdateID(snode->nodetree, gnode->id);
 }
 
-static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup)
-{
-       bNode *node;
-       
-       if(ntree == lookup)
-               return 1;
-       
-       for(node=ntree->nodes.first; node; node=node->next)
-               if(node->type == NODE_GROUP && node->id)
-                       if(has_nodetree((bNodeTree*)node->id, lookup))
-                               return 1;
-       
-       return 0;
-}
-
 void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node)
 {
        int was_active_texture = (node->flag & NODE_ACTIVE_TEXTURE);
 
        nodeSetActive(ntree, node);
        
-       if(node->type!=NODE_GROUP) {
-               int was_output= (node->flag & NODE_DO_OUTPUT);
+       if (node->type != NODE_GROUP) {
+               int was_output = (node->flag & NODE_DO_OUTPUT);
                
                /* tree specific activate calls */
-               if(ntree->type==NTREE_SHADER) {
+               if (ntree->type == NTREE_SHADER) {
                        /* when we select a material, active texture is cleared, for buttons */
-                       if(node->id && ELEM3(GS(node->id->name), ID_MA, ID_LA, ID_WO))
+                       if (node->id && ELEM3(GS(node->id->name), ID_MA, ID_LA, ID_WO))
                                nodeClearActiveID(ntree, ID_TE);
                        
-                       if(node->type==SH_NODE_OUTPUT) {
+                       if (node->type == SH_NODE_OUTPUT) {
                                bNode *tnode;
                                
-                               for(tnode= ntree->nodes.first; tnode; tnode= tnode->next)
-                                       if( tnode->type==SH_NODE_OUTPUT)
+                               for (tnode = ntree->nodes.first; tnode; tnode = tnode->next)
+                                       if (tnode->type == SH_NODE_OUTPUT)
                                                tnode->flag &= ~NODE_DO_OUTPUT;
                                
                                node->flag |= NODE_DO_OUTPUT;
-                               if(was_output==0)
+                               if (was_output == 0)
                                        ED_node_generic_update(bmain, ntree, node);
                        }
 
                        /* if active texture changed, free glsl materials */
-                       if((node->flag & NODE_ACTIVE_TEXTURE) && !was_active_texture) {
+                       if ((node->flag & NODE_ACTIVE_TEXTURE) && !was_active_texture) {
                                Material *ma;
 
-                               for(ma=bmain->mat.first; ma; ma=ma->id.next)
-                                       if(ma->nodetree && ma->use_nodes && has_nodetree(ma->nodetree, ntree))
+                               for (ma = bmain->mat.first; ma; ma = ma->id.next)
+                                       if (ma->nodetree && ma->use_nodes && has_nodetree(ma->nodetree, ntree))
                                                GPU_material_free(ma);
+
+                               WM_main_add_notifier(NC_IMAGE, NULL);
                        }
 
-                       WM_main_add_notifier(NC_MATERIAL|ND_NODES, node->id);
+                       WM_main_add_notifier(NC_MATERIAL | ND_NODES, node->id);
                }
-               else if(ntree->type==NTREE_COMPOSIT) {
+               else if (ntree->type == NTREE_COMPOSIT) {
                        /* make active viewer, currently only 1 supported... */
-                       ifELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
+                       if (ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
                                bNode *tnode;
                                
 
-                               for(tnode= ntree->nodes.first; tnode; tnode= tnode->next)
-                                       ifELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))
+                               for (tnode = ntree->nodes.first; tnode; tnode = tnode->next)
+                                       if (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))
                                                tnode->flag &= ~NODE_DO_OUTPUT;
                                
                                node->flag |= NODE_DO_OUTPUT;
-                               if(was_output==0)
+                               if (was_output == 0)
                                        ED_node_generic_update(bmain, ntree, node);
                                
                                /* addnode() doesnt link this yet... */
-                               node->id= (ID *)BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
+                               node->id = (ID *)BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
                        }
-                       else if(node->type==CMP_NODE_R_LAYERS) {
+                       else if (node->type == CMP_NODE_R_LAYERS) {
                                Scene *scene;
 
-                               for(scene=bmain->scene.first; scene; scene=scene->id.next) {
-                                       if(scene->nodetree && scene->use_nodes && has_nodetree(scene->nodetree, ntree)) {
-                                               if(node->id==NULL || node->id==(ID *)scene) {
-                                                       scene->r.actlay= node->custom1;
+                               for (scene = bmain->scene.first; scene; scene = scene->id.next) {
+                                       if (scene->nodetree && scene->use_nodes && has_nodetree(scene->nodetree, ntree)) {
+                                               if (node->id == NULL || node->id == (ID *)scene) {
+                                                       scene->r.actlay = node->custom1;
                                                }
                                        }
                                }
                        }
-                       else if(node->type==CMP_NODE_COMPOSITE) {
-                               if (was_output==0) {
+                       else if (node->type == CMP_NODE_COMPOSITE) {
+                               if (was_output == 0) {
                                        bNode *tnode;
                                        
-                                       for(tnode= ntree->nodes.first; tnode; tnode= tnode->next)
-                                               if( tnode->type==CMP_NODE_COMPOSITE)
+                                       for (tnode = ntree->nodes.first; tnode; tnode = tnode->next)
+                                               if (tnode->type == CMP_NODE_COMPOSITE)
                                                        tnode->flag &= ~NODE_DO_OUTPUT;
                                        
                                        node->flag |= NODE_DO_OUTPUT;
@@ -679,11 +704,11 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node)
                                }
                        }
                }
-               else if(ntree->type==NTREE_TEXTURE) {
+               else if (ntree->type == NTREE_TEXTURE) {
                        // XXX
 #if 0
-                       if(node->id)
-                               ; // XXX BIF_preview_changed(-1);
+                       if (node->id)
+                               ;  // XXX BIF_preview_changed(-1);
                        // allqueue(REDRAWBUTSSHADING, 1);
                        // allqueue(REDRAWIPO, 0);
 #endif
@@ -691,53 +716,13 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node)
        }
 }
 
-static int inside_rctf(rctf *bounds, rctf *rect)
-{
-       return (bounds->xmin <= rect->xmin && bounds->xmax >= rect->xmax
-                       && bounds->ymin <= rect->ymin && bounds->ymax >= rect->ymax);
-}
-
-static void node_frame_attach_nodes(bNodeTree *UNUSED(ntree), bNode *frame)
-{
-       bNode *node;
-       
-       /* only check nodes on top of the frame for attaching */
-       for (node=frame->next; node; node=node->next) {
-               if (node->parent==frame) {
-                       /* detach nodes that went outside the frame */
-                       if (!inside_rctf(&frame->totr, &node->totr))
-                               nodeDetachNode(node);
-               }
-               else if (node->flag & NODE_SELECT && node->parent==NULL) {
-                       /* attach selected, still unparented nodes */
-                       if (inside_rctf(&frame->totr, &node->totr))
-                               nodeAttachNode(node, frame);
-               }
-       }
-}
-
-void ED_node_update_hierarchy(bContext *UNUSED(C), bNodeTree *ntree)
+void ED_node_post_apply_transform(bContext *UNUSED(C), bNodeTree *UNUSED(ntree))
 {
-       bNode *node;
-       
        /* XXX This does not work due to layout functions relying on node->block,
         * which only exists during actual drawing. Can we rely on valid totr rects?
         */
        /* make sure nodes have correct bounding boxes after transform */
-//     node_update_nodetree(C, ntree, 0.0f, 0.0f);
-       
-       /* all selected nodes are re-parented */
-       for (node=ntree->nodes.last; node; node=node->prev) {
-               if (node->flag & NODE_SELECT && node->parent)
-                       nodeDetachNode(node);
-       }
-       
-       /* update higher Z-level nodes first */
-       for (node=ntree->nodes.last; node; node=node->prev) {
-               /* XXX callback? */
-               if (node->type==NODE_FRAME)
-                       node_frame_attach_nodes(ntree, node);
-       }
+       /* node_update_nodetree(C, ntree, 0.0f, 0.0f); */
 }
 
 /* ***************** generic operator functions for nodes ***************** */
@@ -760,7 +745,7 @@ static void edit_node_properties(wmOperatorType *ot)
 static int edit_node_invoke_properties(bContext *C, wmOperator *op)
 {
        if (!RNA_struct_property_is_set(op->ptr, "node")) {
-               bNode *node= CTX_data_pointer_get_type(C, "node", &RNA_Node).data;
+               bNode *node = CTX_data_pointer_get_type(C, "node", &RNA_Node).data;
                if (!node)
                        return 0;
                else
@@ -779,7 +764,7 @@ static int edit_node_invoke_properties(bContext *C, wmOperator *op)
 static void edit_node_properties_get(wmOperator *op, bNodeTree *ntree, bNode **rnode, bNodeSocket **rsock, int *rin_out)
 {
        bNode *node;
-       bNodeSocket *sock=NULL;
+       bNodeSocket *sock = NULL;
        char nodename[MAX_NAME];
        int sockindex;
        int in_out;
@@ -791,8 +776,8 @@ static void edit_node_properties_get(wmOperator *op, bNodeTree *ntree, bNode **r
        
        sockindex = RNA_int_get(op->ptr, "socket");
        switch (in_out) {
-       case SOCK_IN:   sock = BLI_findlink(&node->inputs, sockindex);  break;
-       case SOCK_OUT:  sock = BLI_findlink(&node->outputs, sockindex); break;
+               case SOCK_IN:   sock = BLI_findlink(&node->inputs, sockindex);  break;
+               case SOCK_OUT:  sock = BLI_findlink(&node->outputs, sockindex); break;
        }
        
        if (rnode)
@@ -811,25 +796,25 @@ void snode_make_group_editable(SpaceNode *snode, bNode *gnode)
        bNode *node;
        
        /* make sure nothing has group editing on */
-       for(node=snode->nodetree->nodes.first; node; node=node->next)
+       for (node = snode->nodetree->nodes.first; node; node = node->next)
                nodeGroupEditClear(node);
        
-       if(gnode==NULL) {
+       if (gnode == NULL) {
                /* with NULL argument we do a toggle */
-               if(snode->edittree==snode->nodetree)
-                       gnode= nodeGetActive(snode->nodetree);
+               if (snode->edittree == snode->nodetree)
+                       gnode = nodeGetActive(snode->nodetree);
        }
        
        if (gnode) {
                snode->edittree = nodeGroupEditSet(gnode, 1);
                
                /* deselect all other nodes, so we can also do grabbing of entire subtree */
-               for(node= snode->nodetree->nodes.first; node; node= node->next)
-                       node->flag &= ~SELECT;
-               gnode->flag |= SELECT;
+               for (node = snode->nodetree->nodes.first; node; node = node->next)
+                       node_deselect(node);
+               node_select(gnode);
        }
        else 
-               snode->edittree= snode->nodetree;
+               snode->edittree = snode->nodetree;
 }
 
 static int node_group_edit_exec(bContext *C, wmOperator *UNUSED(op))
@@ -838,14 +823,14 @@ static int node_group_edit_exec(bContext *C, wmOperator *UNUSED(op))
 
        ED_preview_kill_jobs(C);
 
-       if (snode->nodetree==snode->edittree) {
+       if (snode->nodetree == snode->edittree) {
                bNode *gnode = nodeGetActive(snode->edittree);
                snode_make_group_editable(snode, gnode);
        }
        else
                snode_make_group_editable(snode, NULL);
 
-       WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL);
+       WM_event_add_notifier(C, NC_SCENE | ND_NODES, NULL);
 
        return OPERATOR_FINISHED;
 }
@@ -856,9 +841,9 @@ static int node_group_edit_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(e
        bNode *gnode;
        
        /* XXX callback? */
-       if (snode->nodetree==snode->edittree) {
+       if (snode->nodetree == snode->edittree) {
                gnode = nodeGetActive(snode->edittree);
-               if(gnode && gnode->id && GS(gnode->id->name)==ID_NT && gnode->id->lib) {
+               if (gnode && gnode->id && GS(gnode->id->name) == ID_NT && gnode->id->lib) {
                        uiPupMenuOkee(C, op->type->idname, "Make group local?");
                        return OPERATOR_CANCELLED;
                }
@@ -880,7 +865,7 @@ void NODE_OT_group_edit(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ***************** Add Group Socket operator ************* */
@@ -888,10 +873,10 @@ void NODE_OT_group_edit(wmOperatorType *ot)
 static int node_group_socket_add_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
-       int in_out= -1;
-       char name[MAX_NAME]= "";
-       int type= SOCK_FLOAT;
-       bNodeTree *ngroup= snode->edittree;
+       int in_out = -1;
+       char name[MAX_NAME] = "";
+       int type = SOCK_FLOAT;
+       bNodeTree *ngroup = snode->edittree;
        /* bNodeSocket *sock; */ /* UNUSED */
        
        ED_preview_kill_jobs(C);
@@ -929,7 +914,7 @@ void NODE_OT_group_socket_add(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
        RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Group socket name");
@@ -941,9 +926,9 @@ void NODE_OT_group_socket_add(wmOperatorType *ot)
 static int node_group_socket_remove_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
-       int index= -1;
-       int in_out= -1;
-       bNodeTree *ngroup= snode->edittree;
+       int index = -1;
+       int in_out = -1;
+       bNodeTree *ngroup = snode->edittree;
        bNodeSocket *sock;
        
        ED_preview_kill_jobs(C);
@@ -958,7 +943,7 @@ static int node_group_socket_remove_exec(bContext *C, wmOperator *op)
        else
                return OPERATOR_CANCELLED;
        
-       sock = (bNodeSocket*)BLI_findlink(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, index);
+       sock = (bNodeSocket *)BLI_findlink(in_out == SOCK_IN ? &ngroup->inputs : &ngroup->outputs, index);
        if (sock) {
                node_group_remove_socket(ngroup, sock, in_out);
                ntreeUpdateTree(ngroup);
@@ -981,7 +966,7 @@ void NODE_OT_group_socket_remove(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
        RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
@@ -992,9 +977,9 @@ void NODE_OT_group_socket_remove(wmOperatorType *ot)
 static int node_group_socket_move_up_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
-       int index= -1;
-       int in_out= -1;
-       bNodeTree *ngroup= snode->edittree;
+       int index = -1;
+       int in_out = -1;
+       bNodeTree *ngroup = snode->edittree;
        bNodeSocket *sock, *prev;
        
        ED_preview_kill_jobs(C);
@@ -1010,8 +995,8 @@ static int node_group_socket_move_up_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        
        /* swap */
-       if (in_out==SOCK_IN) {
-               sock = (bNodeSocket*)BLI_findlink(&ngroup->inputs, index);
+       if (in_out == SOCK_IN) {
+               sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index);
                prev = sock->prev;
                /* can't move up the first socket */
                if (!prev)
@@ -1021,8 +1006,8 @@ static int node_group_socket_move_up_exec(bContext *C, wmOperator *op)
                
                ngroup->update |= NTREE_UPDATE_GROUP_IN;
        }
-       else if (in_out==SOCK_OUT) {
-               sock = (bNodeSocket*)BLI_findlink(&ngroup->outputs, index);
+       else if (in_out == SOCK_OUT) {
+               sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index);
                prev = sock->prev;
                /* can't move up the first socket */
                if (!prev)
@@ -1051,7 +1036,7 @@ void NODE_OT_group_socket_move_up(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
        RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
@@ -1062,9 +1047,9 @@ void NODE_OT_group_socket_move_up(wmOperatorType *ot)
 static int node_group_socket_move_down_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
-       int index= -1;
-       int in_out= -1;
-       bNodeTree *ngroup= snode->edittree;
+       int index = -1;
+       int in_out = -1;
+       bNodeTree *ngroup = snode->edittree;
        bNodeSocket *sock, *next;
        
        ED_preview_kill_jobs(C);
@@ -1080,8 +1065,8 @@ static int node_group_socket_move_down_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        
        /* swap */
-       if (in_out==SOCK_IN) {
-               sock = (bNodeSocket*)BLI_findlink(&ngroup->inputs, index);
+       if (in_out == SOCK_IN) {
+               sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index);
                next = sock->next;
                /* can't move down the last socket */
                if (!next)
@@ -1091,8 +1076,8 @@ static int node_group_socket_move_down_exec(bContext *C, wmOperator *op)
                
                ngroup->update |= NTREE_UPDATE_GROUP_IN;
        }
-       else if (in_out==SOCK_OUT) {
-               sock = (bNodeSocket*)BLI_findlink(&ngroup->outputs, index);
+       else if (in_out == SOCK_OUT) {
+               sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index);
                next = sock->next;
                /* can't move down the last socket */
                if (!next)
@@ -1121,7 +1106,7 @@ void NODE_OT_group_socket_move_down(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
        RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output");
@@ -1129,6 +1114,159 @@ void NODE_OT_group_socket_move_down(wmOperatorType *ot)
 
 /* ******************** Ungroup operator ********************** */
 
+/* returns 1 if its OK */
+static int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
+{
+       bNodeLink *link, *linkn;
+       bNode *node, *nextn;
+       bNodeTree *ngroup, *wgroup;
+       ListBase anim_basepaths = {NULL, NULL};
+       
+       ngroup = (bNodeTree *)gnode->id;
+       if (ngroup == NULL) return 0;
+       
+       /* clear new pointers, set in copytree */
+       for (node = ntree->nodes.first; node; node = node->next)
+               node->new_node = NULL;
+       
+       /* wgroup is a temporary copy of the NodeTree we're merging in
+        *      - all of wgroup's nodes are transferred across to their new home
+        *      - ngroup (i.e. the source NodeTree) is left unscathed
+        */
+       wgroup = ntreeCopyTree(ngroup);
+       
+       /* add the nodes into the ntree */
+       for (node = wgroup->nodes.first; node; node = nextn) {
+               nextn = node->next;
+               
+               /* keep track of this node's RNA "base" path (the part of the path identifying the node) 
+                * if the old nodetree has animation data which potentially covers this node
+                */
+               if (wgroup->adt) {
+                       PointerRNA ptr;
+                       char *path;
+                       
+                       RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
+                       path = RNA_path_from_ID_to_struct(&ptr);
+                       
+                       if (path)
+                               BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
+               }
+               
+               /* migrate node */
+               BLI_remlink(&wgroup->nodes, node);
+               BLI_addtail(&ntree->nodes, node);
+               
+               /* ensure unique node name in the nodee tree */
+               nodeUniqueName(ntree, node);
+               
+               node->locx += gnode->locx;
+               node->locy += gnode->locy;
+               
+               node->flag |= NODE_SELECT;
+       }
+       
+       /* restore external links to and from the gnode */
+       for (link = ntree->links.first; link; link = link->next) {
+               if (link->fromnode == gnode) {
+                       if (link->fromsock->groupsock) {
+                               bNodeSocket *gsock = link->fromsock->groupsock;
+                               if (gsock->link) {
+                                       if (gsock->link->fromnode) {
+                                               /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
+                                               link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
+                                               link->fromsock = gsock->link->fromsock->new_sock;
+                                       }
+                                       else {
+                                               /* group output directly maps to group input */
+                                               bNodeSocket *insock = node_group_find_input(gnode, gsock->link->fromsock);
+                                               if (insock->link) {
+                                                       link->fromnode = insock->link->fromnode;
+                                                       link->fromsock = insock->link->fromsock;
+                                               }
+                                       }
+                               }
+                               else {
+                                       /* copy the default input value from the group socket default to the external socket */
+                                       node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value);
+                               }
+                       }
+               }
+       }
+       /* remove internal output links, these are not used anymore */
+       for (link = wgroup->links.first; link; link = linkn) {
+               linkn = link->next;
+               if (!link->tonode)
+                       nodeRemLink(wgroup, link);
+       }
+       /* restore links from internal nodes */
+       for (link = wgroup->links.first; link; link = linkn) {
+               linkn = link->next;
+               /* indicates link to group input */
+               if (!link->fromnode) {
+                       /* NB: can't use find_group_node_input here,
+                        * because gnode sockets still point to the old tree!
+                        */
+                       bNodeSocket *insock;
+                       for (insock = gnode->inputs.first; insock; insock = insock->next)
+                               if (insock->groupsock->new_sock == link->fromsock)
+                                       break;
+                       if (insock->link) {
+                               link->fromnode = insock->link->fromnode;
+                               link->fromsock = insock->link->fromsock;
+                       }
+                       else {
+                               /* copy the default input value from the group node socket default to the internal socket */
+                               node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value);
+                               nodeRemLink(wgroup, link);
+                       }
+               }
+       }
+       
+       /* add internal links to the ntree */
+       for (link = wgroup->links.first; link; link = linkn) {
+               linkn = link->next;
+               BLI_remlink(&wgroup->links, link);
+               BLI_addtail(&ntree->links, link);
+       }
+       
+       /* and copy across the animation,
+        * note that the animation data's action can be NULL here */
+       if (wgroup->adt) {
+               LinkData *ld, *ldn = NULL;
+               bAction *waction;
+               
+               /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
+               waction = wgroup->adt->action = BKE_action_copy(wgroup->adt->action);
+               
+               /* now perform the moving */
+               BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
+               
+               /* paths + their wrappers need to be freed */
+               for (ld = anim_basepaths.first; ld; ld = ldn) {
+                       ldn = ld->next;
+                       
+                       MEM_freeN(ld->data);
+                       BLI_freelinkN(&anim_basepaths, ld);
+               }
+               
+               /* free temp action too */
+               if (waction) {
+                       BKE_libblock_free(&G.main->action, waction);
+               }
+       }
+       
+       /* delete the group instance. this also removes old input links! */
+       nodeFreeNode(ntree, gnode);
+
+       /* free the group tree (takes care of user count) */
+       BKE_libblock_free(&G.main->nodetree, wgroup);
+       
+       ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
+       
+       return 1;
+}
+
 static int node_group_ungroup_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
@@ -1137,19 +1275,22 @@ static int node_group_ungroup_exec(bContext *C, wmOperator *op)
        ED_preview_kill_jobs(C);
 
        /* are we inside of a group? */
-       gnode= node_tree_get_editgroup(snode->nodetree);
-       if(gnode)
+       gnode = node_tree_get_editgroup(snode->nodetree);
+       if (gnode)
                snode_make_group_editable(snode, NULL);
        
-       gnode= nodeGetActive(snode->edittree);
-       if(gnode==NULL)
+       gnode = nodeGetActive(snode->edittree);
+       if (gnode == NULL)
                return OPERATOR_CANCELLED;
        
-       if(gnode->type!=NODE_GROUP) {
+       if (gnode->type != NODE_GROUP) {
                BKE_report(op->reports, RPT_WARNING, "Not a group");
                return OPERATOR_CANCELLED;
        }
-       else if(!node_group_ungroup(snode->edittree, gnode)) {
+       else if (node_group_ungroup(snode->nodetree, gnode)) {
+               ntreeUpdateTree(snode->nodetree);
+       }
+       else {
                BKE_report(op->reports, RPT_WARNING, "Can't ungroup");
                return OPERATOR_CANCELLED;
        }
@@ -1172,7 +1313,204 @@ void NODE_OT_group_ungroup(wmOperatorType *ot)
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ******************** Separate operator ********************** */
+
+/* returns 1 if its OK */
+static int node_group_separate_selected(bNodeTree *ntree, bNode *gnode, int make_copy)
+{
+       bNodeLink *link, *link_next;
+       bNode *node, *node_next, *newnode;
+       bNodeTree *ngroup;
+       ListBase anim_basepaths = {NULL, NULL};
+       
+       ngroup = (bNodeTree *)gnode->id;
+       if (ngroup == NULL) return 0;
+       
+       /* deselect all nodes in the target tree */
+       for (node = ntree->nodes.first; node; node = node->next)
+               node_deselect(node);
+       
+       /* clear new pointers, set in nodeCopyNode */
+       for (node = ngroup->nodes.first; node; node = node->next)
+               node->new_node = NULL;
+       
+       /* add selected nodes into the ntree */
+       for (node = ngroup->nodes.first; node; node = node_next) {
+               node_next = node->next;
+               if (!(node->flag & NODE_SELECT))
+                       continue;
+               
+               if (make_copy) {
+                       /* make a copy */
+                       newnode = nodeCopyNode(ngroup, node);
+               }
+               else {
+                       /* use the existing node */
+                       newnode = node;
+               }
+               
+               /* keep track of this node's RNA "base" path (the part of the path identifying the node) 
+                * if the old nodetree has animation data which potentially covers this node
+                */
+               if (ngroup->adt) {
+                       PointerRNA ptr;
+                       char *path;
+                       
+                       RNA_pointer_create(&ngroup->id, &RNA_Node, newnode, &ptr);
+                       path = RNA_path_from_ID_to_struct(&ptr);
+                       
+                       if (path)
+                               BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
+               }
+               
+               /* ensure valid parent pointers, detach if parent stays inside the group */
+               if (newnode->parent && !(newnode->parent->flag & NODE_SELECT))
+                       nodeDetachNode(newnode);
+               
+               /* migrate node */
+               BLI_remlink(&ngroup->nodes, newnode);
+               BLI_addtail(&ntree->nodes, newnode);
+               
+               /* ensure unique node name in the node tree */
+               nodeUniqueName(ntree, newnode);
+               
+               newnode->locx += gnode->locx;
+               newnode->locy += gnode->locy;
+       }
+       
+       /* add internal links to the ntree */
+       for (link = ngroup->links.first; link; link = link_next) {
+               int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT));
+               int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT));
+               link_next = link->next;
+               
+               if (make_copy) {
+                       /* make a copy of internal links */
+                       if (fromselect && toselect)
+                               nodeAddLink(ntree, link->fromnode->new_node, link->fromsock->new_sock, link->tonode->new_node, link->tosock->new_sock);
+               }
+               else {
+                       /* move valid links over, delete broken links */
+                       if (fromselect && toselect) {
+                               BLI_remlink(&ngroup->links, link);
+                               BLI_addtail(&ntree->links, link);
+                       }
+                       else if (fromselect || toselect) {
+                               nodeRemLink(ngroup, link);
+                       }
+               }
+       }
+       
+       /* and copy across the animation,
+        * note that the animation data's action can be NULL here */
+       if (ngroup->adt) {
+               LinkData *ld, *ldn = NULL;
+               
+               /* now perform the moving */
+               BKE_animdata_separate_by_basepath(&ngroup->id, &ntree->id, &anim_basepaths);
+               
+               /* paths + their wrappers need to be freed */
+               for (ld = anim_basepaths.first; ld; ld = ldn) {
+                       ldn = ld->next;
+                       
+                       MEM_freeN(ld->data);
+                       BLI_freelinkN(&anim_basepaths, ld);
+               }
+       }
+       
+       ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
+       if (!make_copy)
+               ngroup->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
+       
+       return 1;
+}
+
+typedef enum eNodeGroupSeparateType {
+       NODE_GS_COPY,
+       NODE_GS_MOVE
+} eNodeGroupSeparateType;
+
+/* Operator Property */
+EnumPropertyItem node_group_separate_types[] = {
+       {NODE_GS_COPY, "COPY", 0, "Copy", "Copy to parent node tree, keep group intact"},
+       {NODE_GS_MOVE, "MOVE", 0, "Move", "Move to parent node tree, remove from group"},
+       {0, NULL, 0, NULL, NULL}
+};
+
+static int node_group_separate_exec(bContext *C, wmOperator *op)
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNode *gnode;
+       int type = RNA_enum_get(op->ptr, "type");
+
+       ED_preview_kill_jobs(C);
+
+       /* are we inside of a group? */
+       gnode = node_tree_get_editgroup(snode->nodetree);
+       if (!gnode) {
+               BKE_report(op->reports, RPT_WARNING, "Not inside node group");
+               return OPERATOR_CANCELLED;
+       }
+       
+       switch (type) {
+               case NODE_GS_COPY:
+                       if (!node_group_separate_selected(snode->nodetree, gnode, 1)) {
+                               BKE_report(op->reports, RPT_WARNING, "Can't separate nodes");
+                               return OPERATOR_CANCELLED;
+                       }
+                       break;
+               case NODE_GS_MOVE:
+                       if (!node_group_separate_selected(snode->nodetree, gnode, 0)) {
+                               BKE_report(op->reports, RPT_WARNING, "Can't separate nodes");
+                               return OPERATOR_CANCELLED;
+                       }
+                       break;
+       }
+       
+       /* switch to parent tree */
+       snode_make_group_editable(snode, NULL);
+       
+       ntreeUpdateTree(snode->nodetree);
+       
+       snode_notify(C, snode);
+       snode_dag_update(C, snode);
+
+       return OPERATOR_FINISHED;
+}
+
+static int node_group_separate_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *UNUSED(event))
+{
+       uiPopupMenu *pup = uiPupMenuBegin(C, "Separate", ICON_NONE);
+       uiLayout *layout = uiPupMenuLayout(pup);
+       
+       uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
+       uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_COPY);
+       uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_MOVE);
+       
+       uiPupMenuEnd(C, pup);
+       
+       return OPERATOR_CANCELLED;
+}
+
+void NODE_OT_group_separate(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Separate";
+       ot->description = "Separate selected nodes from the node group";
+       ot->idname = "NODE_OT_group_separate";
+       
+       /* api callbacks */
+       ot->invoke = node_group_separate_invoke;
+       ot->exec = node_group_separate_exec;
+       ot->poll = ED_operator_node_active;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       
+       RNA_def_enum(ot->srna, "type", node_group_separate_types, NODE_GS_COPY, "Type", "");
 }
 
 /* ************************** Node generic ************** */
@@ -1182,8 +1520,8 @@ static bNode *visible_node(SpaceNode *snode, rctf *rct)
 {
        bNode *node;
        
-       for(node=snode->edittree->nodes.last; node; node=node->prev) {
-               if(BLI_isect_rctf(&node->totr, rct, NULL))
+       for (node = snode->edittree->nodes.last; node; node = node->prev) {
+               if (BLI_rctf_isect(&node->totr, rct, NULL))
                        break;
        }
        return node;
@@ -1198,17 +1536,17 @@ typedef struct NodeViewMove {
 
 static int snode_bg_viewmove_modal(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       NodeViewMove *nvm= op->customdata;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       NodeViewMove *nvm = op->customdata;
 
        switch (event->type) {
                case MOUSEMOVE:
                        
-                       snode->xof -= (nvm->mvalo[0]-event->mval[0]);
-                       snode->yof -= (nvm->mvalo[1]-event->mval[1]);
-                       nvm->mvalo[0]= event->mval[0];
-                       nvm->mvalo[1]= event->mval[1];
+                       snode->xof -= (nvm->mvalo[0] - event->mval[0]);
+                       snode->yof -= (nvm->mvalo[1] - event->mval[1]);
+                       nvm->mvalo[0] = event->mval[0];
+                       nvm->mvalo[1] = event->mval[1];
                        
                        /* prevent dragging image outside of the window and losing it! */
                        CLAMP(snode->xof, nvm->xmin, nvm->xmax);
@@ -1223,9 +1561,7 @@ static int snode_bg_viewmove_modal(bContext *C, wmOperator *op, wmEvent *event)
                case RIGHTMOUSE:
                        
                        MEM_freeN(nvm);
-                       op->customdata= NULL;
-
-                       WM_event_add_notifier(C, NC_SPACE|ND_SPACE_NODE, NULL);
+                       op->customdata = NULL;
                        
                        return OPERATOR_FINISHED;
        }
@@ -1235,30 +1571,32 @@ static int snode_bg_viewmove_modal(bContext *C, wmOperator *op, wmEvent *event)
 
 static int snode_bg_viewmove_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       ARegion *ar= CTX_wm_region(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
        NodeViewMove *nvm;
        Image *ima;
        ImBuf *ibuf;
-       int pad= 10;
+       const float pad = 32.0f; /* better be bigger then scrollbars */
+
        void *lock;
        
-       ima= BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
-       ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
+       ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
+       ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
        
-       if(ibuf == NULL) {
+       if (ibuf == NULL) {
                BKE_image_release_ibuf(ima, lock);
                return OPERATOR_CANCELLED;
        }
 
-       nvm= MEM_callocN(sizeof(NodeViewMove), "NodeViewMove struct");
-       op->customdata= nvm;
-       nvm->mvalo[0]= event->mval[0];
-       nvm->mvalo[1]= event->mval[1];
+       nvm = MEM_callocN(sizeof(NodeViewMove), "NodeViewMove struct");
+       op->customdata = nvm;
+       nvm->mvalo[0] = event->mval[0];
+       nvm->mvalo[1] = event->mval[1];
 
-       nvm->xmin = -(ar->winx/2) - ibuf->x/2 + pad;
-       nvm->xmax = ar->winx/2 + ibuf->x/2 - pad;
-       nvm->ymin = -(ar->winy/2) - ibuf->y/2 + pad;
-       nvm->ymax = ar->winy/2 + ibuf->y/2 - pad;
+       nvm->xmin = -(ar->winx / 2) - (ibuf->x * (0.5f * snode->zoom)) + pad;
+       nvm->xmax =  (ar->winx / 2) + (ibuf->x * (0.5f * snode->zoom)) - pad;
+       nvm->ymin = -(ar->winy / 2) - (ibuf->y * (0.5f * snode->zoom)) + pad;
+       nvm->ymax =  (ar->winy / 2) + (ibuf->y * (0.5f * snode->zoom)) - pad;
 
        BKE_image_release_ibuf(ima, lock);
        
@@ -1271,7 +1609,7 @@ static int snode_bg_viewmove_invoke(bContext *C, wmOperator *op, wmEvent *event)
 static int snode_bg_viewmove_cancel(bContext *UNUSED(C), wmOperator *op)
 {
        MEM_freeN(op->customdata);
-       op->customdata= NULL;
+       op->customdata = NULL;
 
        return OPERATOR_CANCELLED;
 }
@@ -1279,25 +1617,25 @@ static int snode_bg_viewmove_cancel(bContext *UNUSED(C), wmOperator *op)
 void NODE_OT_backimage_move(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Background Image Move";
+       ot->name = "Background Image Move";
        ot->description = "Move Node backdrop";
-       ot->idname= "NODE_OT_backimage_move";
+       ot->idname = "NODE_OT_backimage_move";
        
        /* api callbacks */
-       ot->invoke= snode_bg_viewmove_invoke;
-       ot->modal= snode_bg_viewmove_modal;
-       ot->poll= composite_node_active;
-       ot->cancel= snode_bg_viewmove_cancel;
+       ot->invoke = snode_bg_viewmove_invoke;
+       ot->modal = snode_bg_viewmove_modal;
+       ot->poll = composite_node_active;
+       ot->cancel = snode_bg_viewmove_cancel;
        
        /* flags */
-       ot->flag= OPTYPE_BLOCKING|OPTYPE_GRAB_POINTER;
+       ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_POINTER;
 }
 
 static int backimage_zoom(bContext *C, wmOperator *op)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       float fac= RNA_float_get(op->ptr, "factor");
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       float fac = RNA_float_get(op->ptr, "factor");
 
        snode->zoom *= fac;
        ED_region_tag_redraw(ar);
@@ -1310,15 +1648,16 @@ void NODE_OT_backimage_zoom(wmOperatorType *ot)
 {
        
        /* identifiers */
-       ot->name= "Background Image Zoom";
-       ot->idname= "NODE_OT_backimage_zoom";
+       ot->name = "Background Image Zoom";
+       ot->idname = "NODE_OT_backimage_zoom";
+       ot->description = "Zoom in/out the background image";
        
        /* api callbacks */
-       ot->exec= backimage_zoom;
-       ot->poll= composite_node_active;
+       ot->exec = backimage_zoom;
+       ot->poll = composite_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_BLOCKING;
 
        /* internal */
        RNA_def_float(ot->srna, "factor", 1.2f, 0.0f, 10.0f, "Factor", "", 0.0f, 10.0f);
@@ -1341,31 +1680,36 @@ typedef struct ImageSampleInfo {
 
 static void sample_draw(const bContext *C, ARegion *ar, void *arg_info)
 {
-       ImageSampleInfo *info= arg_info;
-
-       ED_image_draw_info(ar, (CTX_data_scene(C)->r.color_mgt_flag & R_COLOR_MANAGEMENT), info->channels,
-                          info->x, info->y, info->col, info->colf,
-                          NULL, NULL /* zbuf - unused for nodes */
-                          );
+       Scene *scene = CTX_data_scene(C);
+       ImageSampleInfo *info = arg_info;
+
+       if (info->draw) {
+               ED_image_draw_info(ar, (scene->r.color_mgt_flag & R_COLOR_MANAGEMENT), info->channels,
+                                  info->x, info->y, info->col, info->colf,
+                                  NULL, NULL /* zbuf - unused for nodes */
+                                  );
+       }
 }
 
 static void sample_apply(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       ImageSampleInfo *info= op->customdata;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       ImageSampleInfo *info = op->customdata;
        void *lock;
        Image *ima;
        ImBuf *ibuf;
        float fx, fy, bufx, bufy;
        
-       ima= BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
-       ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
-       if(!ibuf)
+       ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
+       ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+       if (!ibuf) {
+               info->draw = 0;
                return;
+       }
        
-       if(!ibuf->rect) {
-               if(info->color_manage)
+       if (!ibuf->rect) {
+               if (info->color_manage)
                        ibuf->profile = IB_PROFILE_LINEAR_RGB;
                else
                        ibuf->profile = IB_PROFILE_NONE;
@@ -1375,46 +1719,50 @@ static void sample_apply(bContext *C, wmOperator *op, wmEvent *event)
        /* map the mouse coords to the backdrop image space */
        bufx = ibuf->x * snode->zoom;
        bufy = ibuf->y * snode->zoom;
-       fx = (bufx > 0.0f ? ((float)event->mval[0] - 0.5f*ar->winx - snode->xof) / bufx + 0.5f : 0.0f);
-       fy = (bufy > 0.0f ? ((float)event->mval[1] - 0.5f*ar->winy - snode->yof) / bufy + 0.5f : 0.0f);
+       fx = (bufx > 0.0f ? ((float)event->mval[0] - 0.5f * ar->winx - snode->xof) / bufx + 0.5f : 0.0f);
+       fy = (bufy > 0.0f ? ((float)event->mval[1] - 0.5f * ar->winy - snode->yof) / bufy + 0.5f : 0.0f);
 
-       if(fx>=0.0f && fy>=0.0f && fx<1.0f && fy<1.0f) {
+       if (fx >= 0.0f && fy >= 0.0f && fx < 1.0f && fy < 1.0f) {
                float *fp;
                char *cp;
-               int x= (int)(fx*ibuf->x), y= (int)(fy*ibuf->y);
+               int x = (int)(fx * ibuf->x), y = (int)(fy * ibuf->y);
 
-               CLAMP(x, 0, ibuf->x-1);
-               CLAMP(y, 0, ibuf->y-1);
+               CLAMP(x, 0, ibuf->x - 1);
+               CLAMP(y, 0, ibuf->y - 1);
 
-               info->x= x;
-               info->y= y;
-               info->draw= 1;
-               info->channels= ibuf->channels;
+               info->x = x;
+               info->y = y;
+               info->draw = 1;
+               info->channels = ibuf->channels;
 
-               if(ibuf->rect) {
-                       cp= (char *)(ibuf->rect + y*ibuf->x + x);
+               if (ibuf->rect) {
+                       cp = (char *)(ibuf->rect + y * ibuf->x + x);
 
-                       info->col[0]= cp[0];
-                       info->col[1]= cp[1];
-                       info->col[2]= cp[2];
-                       info->col[3]= cp[3];
+                       info->col[0] = cp[0];
+                       info->col[1] = cp[1];
+                       info->col[2] = cp[2];
+                       info->col[3] = cp[3];
 
-                       info->colf[0]= (float)cp[0]/255.0f;
-                       info->colf[1]= (float)cp[1]/255.0f;
-                       info->colf[2]= (float)cp[2]/255.0f;
-                       info->colf[3]= (float)cp[3]/255.0f;
+                       info->colf[0] = (float)cp[0] / 255.0f;
+                       info->colf[1] = (float)cp[1] / 255.0f;
+                       info->colf[2] = (float)cp[2] / 255.0f;
+                       info->colf[3] = (float)cp[3] / 255.0f;
                }
-               if(ibuf->rect_float) {
-                       fp= (ibuf->rect_float + (ibuf->channels)*(y*ibuf->x + x));
+               if (ibuf->rect_float) {
+                       fp = (ibuf->rect_float + (ibuf->channels) * (y * ibuf->x + x));
 
-                       info->colf[0]= fp[0];
-                       info->colf[1]= fp[1];
-                       info->colf[2]= fp[2];
-                       info->colf[3]= fp[3];
+                       info->colf[0] = fp[0];
+                       info->colf[1] = fp[1];
+                       info->colf[2] = fp[2];
+                       info->colf[3] = fp[3];
                }
+
+               ED_node_sample_set(info->colf);
+       }
+       else {
+               info->draw = 0;
+               ED_node_sample_set(NULL);
        }
-       else
-               info->draw= 0;
 
        BKE_image_release_ibuf(ima, lock);
        
@@ -1423,8 +1771,9 @@ static void sample_apply(bContext *C, wmOperator *op, wmEvent *event)
 
 static void sample_exit(bContext *C, wmOperator *op)
 {
-       ImageSampleInfo *info= op->customdata;
+       ImageSampleInfo *info = op->customdata;
 
+       ED_node_sample_set(NULL);
        ED_region_draw_cb_exit(info->art, info->draw_handle);
        ED_area_tag_redraw(CTX_wm_area(C));
        MEM_freeN(info);
@@ -1432,17 +1781,17 @@ static void sample_exit(bContext *C, wmOperator *op)
 
 static int sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
        ImageSampleInfo *info;
 
-       if(snode->treetype!=NTREE_COMPOSIT || !(snode->flag & SNODE_BACKDRAW))
+       if (snode->treetype != NTREE_COMPOSIT || !(snode->flag & SNODE_BACKDRAW))
                return OPERATOR_CANCELLED;
        
-       info= MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo");
-       info->art= ar->type;
+       info = MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo");
+       info->art = ar->type;
        info->draw_handle = ED_region_draw_cb_activate(ar->type, sample_draw, info, REGION_DRAW_POST_PIXEL);
-       op->customdata= info;
+       op->customdata = info;
 
        sample_apply(C, op, event);
 
@@ -1453,7 +1802,7 @@ static int sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
 
 static int sample_modal(bContext *C, wmOperator *op, wmEvent *event)
 {
-       switch(event->type) {
+       switch (event->type) {
                case LEFTMOUSE:
                case RIGHTMOUSE: // XXX hardcoded
                        sample_exit(C, op);
@@ -1475,53 +1824,148 @@ static int sample_cancel(bContext *C, wmOperator *op)
 void NODE_OT_backimage_sample(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Backimage Sample";
-       ot->idname= "NODE_OT_backimage_sample";
+       ot->name = "Backimage Sample";
+       ot->idname = "NODE_OT_backimage_sample";
+       ot->description = "Use mouse to sample background image";
        
        /* api callbacks */
-       ot->invoke= sample_invoke;
-       ot->modal= sample_modal;
-       ot->cancel= sample_cancel;
-       ot->poll= ED_operator_node_active;
+       ot->invoke = sample_invoke;
+       ot->modal = sample_modal;
+       ot->cancel = sample_cancel;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_BLOCKING;
 }
 
 /* ********************** size widget operator ******************** */
 
 typedef struct NodeSizeWidget {
        float mxstart, mystart;
+       float oldlocx, oldlocy;
+       float oldoffsetx, oldoffsety;
        float oldwidth, oldheight;
        float oldminiwidth;
+       int directions;
 } NodeSizeWidget;
 
+static void node_resize_init(bContext *C, wmOperator *op, wmEvent *UNUSED(event), bNode *node, int dir)
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       
+       NodeSizeWidget *nsw = MEM_callocN(sizeof(NodeSizeWidget), "size widget op data");
+       
+       op->customdata = nsw;
+       nsw->mxstart = snode->mx;
+       nsw->mystart = snode->my;
+       
+       /* store old */
+       nsw->oldlocx = node->locx;
+       nsw->oldlocy = node->locy;
+       nsw->oldoffsetx = node->offsetx;
+       nsw->oldoffsety = node->offsety;
+       nsw->oldwidth = node->width;
+       nsw->oldheight = node->height;
+       nsw->oldminiwidth = node->miniwidth;
+       nsw->directions = dir;
+       
+       WM_cursor_modal(CTX_wm_window(C), node_get_resize_cursor(dir));
+       /* add modal handler */
+       WM_event_add_modal_handler(C, op);
+}
+
+static void node_resize_exit(bContext *C, wmOperator *op, int UNUSED(cancel))
+{
+       WM_cursor_restore(CTX_wm_window(C));
+       
+       MEM_freeN(op->customdata);
+       op->customdata = NULL;
+}
+
 static int node_resize_modal(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       bNode *node= editnode_get_active(snode->edittree);
-       NodeSizeWidget *nsw= op->customdata;
-       float mx, my;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       bNode *node = editnode_get_active(snode->edittree);
+       NodeSizeWidget *nsw = op->customdata;
+       float mx, my, dx, dy;
        
        switch (event->type) {
                case MOUSEMOVE:
                        
-                       UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1],
-                                                                        &mx, &my);
+                       UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &mx, &my);
+                       dx = mx - nsw->mxstart;
+                       dy = my - nsw->mystart;
                        
                        if (node) {
-                               if(node->flag & NODE_HIDDEN) {
-                                       node->miniwidth= nsw->oldminiwidth + mx - nsw->mxstart;
-                                       CLAMP(node->miniwidth, 0.0f, 100.0f);
+                               if (node->flag & NODE_HIDDEN) {
+                                       float widthmin = 0.0f;
+                                       float widthmax = 100.0f;
+                                       if (nsw->directions & NODE_RESIZE_RIGHT) {
+                                               node->miniwidth = nsw->oldminiwidth + dx;
+                                               CLAMP(node->miniwidth, widthmin, widthmax);
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_LEFT) {
+                                               float locmax = nsw->oldlocx + nsw->oldminiwidth;
+                                               
+                                               node->locx = nsw->oldlocx + dx;
+                                               CLAMP(node->locx, locmax - widthmax, locmax - widthmin);
+                                               node->miniwidth = locmax - node->locx;
+                                       }
                                }
                                else {
-                                       node->width= nsw->oldwidth + mx - nsw->mxstart;
-                                       CLAMP(node->width, UI_DPI_FAC*node->typeinfo->minwidth, UI_DPI_FAC*node->typeinfo->maxwidth);
+                                       float widthmin = UI_DPI_FAC * node->typeinfo->minwidth;
+                                       float widthmax = UI_DPI_FAC * node->typeinfo->maxwidth;
+                                       if (nsw->directions & NODE_RESIZE_RIGHT) {
+                                               node->width = nsw->oldwidth + dx;
+                                               CLAMP(node->width, widthmin, widthmax);
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_LEFT) {
+                                               float locmax = nsw->oldlocx + nsw->oldwidth;
+                                               
+                                               node->locx = nsw->oldlocx + dx;
+                                               CLAMP(node->locx, locmax - widthmax, locmax - widthmin);
+                                               node->width = locmax - node->locx;
+                                       }
                                }
+                       
                                /* height works the other way round ... */
-                               node->height= nsw->oldheight - my + nsw->mystart;
-                               CLAMP(node->height, node->typeinfo->minheight, node->typeinfo->maxheight);
+                               {
+                                       float heightmin = UI_DPI_FAC * node->typeinfo->minheight;
+                                       float heightmax = UI_DPI_FAC * node->typeinfo->maxheight;
+                                       if (nsw->directions & NODE_RESIZE_TOP) {
+                                               float locmin = nsw->oldlocy - nsw->oldheight;
+                                               
+                                               node->locy = nsw->oldlocy + dy;
+                                               CLAMP(node->locy, locmin + heightmin, locmin + heightmax);
+                                               node->height = node->locy - locmin;
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_BOTTOM) {
+                                               node->height = nsw->oldheight - dy;
+                                               CLAMP(node->height, heightmin, heightmax);
+                                       }
+                               }
+                               
+                               /* XXX make callback? */
+                               if (node->type == NODE_FRAME) {
+                                       /* keep the offset symmetric around center point */
+                                       if (nsw->directions & NODE_RESIZE_LEFT) {
+                                               node->locx = nsw->oldlocx + 0.5f * dx;
+                                               node->offsetx = nsw->oldoffsetx + 0.5f * dx;
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_RIGHT) {
+                                               node->locx = nsw->oldlocx + 0.5f * dx;
+                                               node->offsetx = nsw->oldoffsetx - 0.5f * dx;
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_TOP) {
+                                               node->locy = nsw->oldlocy + 0.5f * dy;
+                                               node->offsety = nsw->oldoffsety + 0.5f * dy;
+                                       }
+                                       if (nsw->directions & NODE_RESIZE_BOTTOM) {
+                                               node->locy = nsw->oldlocy + 0.5f * dy;
+                                               node->offsety = nsw->oldoffsety - 0.5f * dy;
+                                       }
+                               }
                        }
                                
                        ED_region_tag_redraw(ar);
@@ -1532,10 +1976,8 @@ static int node_resize_modal(bContext *C, wmOperator *op, wmEvent *event)
                case MIDDLEMOUSE:
                case RIGHTMOUSE:
                        
-                       MEM_freeN(nsw);
-                       op->customdata= NULL;
-                       
-                       ED_node_update_hierarchy(C, snode->edittree);
+                       node_resize_exit(C, op, 0);
+                       ED_node_post_apply_transform(C, snode->edittree);
                        
                        return OPERATOR_FINISHED;
        }
@@ -1545,40 +1987,27 @@ static int node_resize_modal(bContext *C, wmOperator *op, wmEvent *event)
 
 static int node_resize_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       bNode *node= editnode_get_active(snode->edittree);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       bNode *node = editnode_get_active(snode->edittree);
+       int dir;
        
-       if(node) {
+       if (node) {
                /* convert mouse coordinates to v2d space */
                UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1],
-                                                                &snode->mx, &snode->my);
-               
-               if(node->typeinfo->resize_area_func(node, snode->mx, snode->my)) {
-                       NodeSizeWidget *nsw= MEM_callocN(sizeof(NodeSizeWidget), "size widget op data");
-                       
-                       op->customdata= nsw;
-                       nsw->mxstart= snode->mx;
-                       nsw->mystart= snode->my;
-                       
-                       /* store old */
-                       nsw->oldwidth= node->width;
-                       nsw->oldheight= node->height;
-                       nsw->oldminiwidth= node->miniwidth;
-                       
-                       /* add modal handler */
-                       WM_event_add_modal_handler(C, op);
-
+                                        &snode->mx, &snode->my);
+               dir = node->typeinfo->resize_area_func(node, snode->mx, snode->my);
+               if (dir != 0) {
+                       node_resize_init(C, op, event, node, dir);
                        return OPERATOR_RUNNING_MODAL;
                }
        }
-       return OPERATOR_CANCELLED|OPERATOR_PASS_THROUGH;
+       return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
 }
 
-static int node_resize_cancel(bContext *UNUSED(C), wmOperator *op)
+static int node_resize_cancel(bContext *C, wmOperator *op)
 {
-       MEM_freeN(op->customdata);
-       op->customdata= NULL;
+       node_resize_exit(C, op, 1);
 
        return OPERATOR_CANCELLED;
 }
@@ -1586,144 +2015,169 @@ static int node_resize_cancel(bContext *UNUSED(C), wmOperator *op)
 void NODE_OT_resize(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Resize Node";
-       ot->idname= "NODE_OT_resize";
+       ot->name = "Resize Node";
+       ot->idname = "NODE_OT_resize";
+       ot->description = "Resize a node";
        
        /* api callbacks */
-       ot->invoke= node_resize_invoke;
-       ot->modal= node_resize_modal;
-       ot->poll= ED_operator_node_active;
-       ot->cancel= node_resize_cancel;
+       ot->invoke = node_resize_invoke;
+       ot->modal = node_resize_modal;
+       ot->poll = ED_operator_node_active;
+       ot->cancel = node_resize_cancel;
        
        /* flags */
-       ot->flag= OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_BLOCKING;
 }
 
 
 /* ********************** hidden sockets ******************** */
 
-int node_has_hidden_sockets(bNode *node, short flag)
+int node_has_hidden_sockets(bNode *node)
 {
        bNodeSocket *sock;
        
-       for(sock= node->inputs.first; sock; sock= sock->next)
-               if(sock->flag & flag)
+       for (sock = node->inputs.first; sock; sock = sock->next)
+               if (sock->flag & SOCK_HIDDEN)
                        return 1;
-       for(sock= node->outputs.first; sock; sock= sock->next)
-               if(sock->flag & flag)
+       for (sock = node->outputs.first; sock; sock = sock->next)
+               if (sock->flag & SOCK_HIDDEN)
                        return 1;
        return 0;
 }
 
-void node_set_hidden_sockets(SpaceNode *snode, bNode *node, short flag, int set)
-{      
+void node_set_hidden_sockets(SpaceNode *snode, bNode *node, int set)
+{
        bNodeSocket *sock;
 
-       if(set==0) {
-               for(sock= node->inputs.first; sock; sock= sock->next)
-                       sock->flag &= ~flag;
-               for(sock= node->outputs.first; sock; sock= sock->next)
-                       sock->flag &= ~flag;
+       if (set == 0) {
+               for (sock = node->inputs.first; sock; sock = sock->next)
+                       sock->flag &= ~SOCK_HIDDEN;
+               for (sock = node->outputs.first; sock; sock = sock->next)
+                       sock->flag &= ~SOCK_HIDDEN;
        }
        else {
                /* hide unused sockets */
-               for(sock= node->inputs.first; sock; sock= sock->next) {
-                       if(sock->link==NULL)
-                               sock->flag |= flag;
+               for (sock = node->inputs.first; sock; sock = sock->next) {
+                       if (sock->link == NULL)
+                               sock->flag |= SOCK_HIDDEN;
                }
-               for(sock= node->outputs.first; sock; sock= sock->next) {
-                       if(nodeCountSocketLinks(snode->edittree, sock)==0)
-                               sock->flag |= flag;
+               for (sock = node->outputs.first; sock; sock = sock->next) {
+                       if (nodeCountSocketLinks(snode->edittree, sock) == 0)
+                               sock->flag |= SOCK_HIDDEN;
                }
        }
 }
 
-static void node_link_viewer(SpaceNode *snode, bNode *tonode)
+static int node_link_viewer(const bContext *C, bNode *tonode)
 {
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node;
+       bNodeLink *link;
+       bNodeSocket *sock;
 
        /* context check */
-       if(tonode==NULL || tonode->outputs.first==NULL)
-               return;
-       if( ELEM(tonode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) 
-               return;
+       if (tonode == NULL || tonode->outputs.first == NULL)
+               return OPERATOR_CANCELLED;
+       if (ELEM(tonode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))
+               return OPERATOR_CANCELLED;
        
        /* get viewer */
-       for(node= snode->edittree->nodes.first; node; node= node->next)
-               if( ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) 
-                       if(node->flag & NODE_DO_OUTPUT)
+       for (node = snode->edittree->nodes.first; node; node = node->next)
+               if (ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))
+                       if (node->flag & NODE_DO_OUTPUT)
                                break;
        /* no viewer, we make one active */
-       if(node==NULL) {
-               for(node= snode->edittree->nodes.first; node; node= node->next) {
-                       ifELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
+       if (node == NULL) {
+               for (node = snode->edittree->nodes.first; node; node = node->next) {
+                       if (ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
                                node->flag |= NODE_DO_OUTPUT;
                                break;
                        }
                }
        }
-               
-       if(node) {
-               bNodeLink *link;
-               bNodeSocket *sock= NULL;
-
-               /* try to find an already connected socket to cycle to the next */
-               for(link= snode->edittree->links.first; link; link= link->next)
-                       if(link->tonode==node && link->fromnode==tonode)
-                               if(link->tosock==node->inputs.first)
+       
+       sock = NULL;
+       
+       /* try to find an already connected socket to cycle to the next */
+       if (node) {
+               link = NULL;
+               for (link = snode->edittree->links.first; link; link = link->next)
+                       if (link->tonode == node && link->fromnode == tonode)
+                               if (link->tosock == node->inputs.first)
                                        break;
-
-               if(link) {
+               if (link) {
                        /* unlink existing connection */
-                       sock= link->fromsock;
+                       sock = link->fromsock;
                        nodeRemLink(snode->edittree, link);
-
+                       
                        /* find a socket after the previously connected socket */
-                       for(sock=sock->next; sock; sock= sock->next)
-                               if(!nodeSocketIsHidden(sock))
+                       for (sock = sock->next; sock; sock = sock->next)
+                               if (!nodeSocketIsHidden(sock))
                                        break;
                }
-
-               /* find a socket starting from the first socket */
-               if(!sock) {
-                       for(sock= tonode->outputs.first; sock; sock= sock->next)
-                               if(!nodeSocketIsHidden(sock))
-                                       break;
+       }
+       
+       /* find a socket starting from the first socket */
+       if (!sock) {
+               for (sock = tonode->outputs.first; sock; sock = sock->next)
+                       if (!nodeSocketIsHidden(sock))
+                               break;
+       }
+       
+       if (sock) {
+               /* add a new viewer if none exists yet */
+               if (!node) {
+                       Main *bmain = CTX_data_main(C);
+                       Scene *scene = CTX_data_scene(C);
+                       bNodeTemplate ntemp;
+                       
+                       ntemp.type = CMP_NODE_VIEWER;
+                       /* XXX location is a quick hack, just place it next to the linked socket */
+                       node = node_add_node(snode, bmain, scene, &ntemp, sock->locx + 100, sock->locy);
+                       if (!node)
+                               return OPERATOR_CANCELLED;
+                       
+                       link = NULL;
                }
-               
-               if(sock) {
+               else {
                        /* get link to viewer */
-                       for(link= snode->edittree->links.first; link; link= link->next)
-                               if(link->tonode==node && link->tosock==node->inputs.first)
+                       for (link = snode->edittree->links.first; link; link = link->next)
+                               if (link->tonode == node && link->tosock == node->inputs.first)
                                        break;
-                       
-                       if(link==NULL) {
-                               nodeAddLink(snode->edittree, tonode, sock, node, node->inputs.first);
-                       }
-                       else {
-                               link->fromnode= tonode;
-                               link->fromsock= sock;
-                       }
-                       ntreeUpdateTree(snode->edittree);
-                       snode_update(snode, node);
                }
+               
+               if (link == NULL) {
+                       nodeAddLink(snode->edittree, tonode, sock, node, node->inputs.first);
+               }
+               else {
+                       link->fromnode = tonode;
+                       link->fromsock = sock;
+                       /* make sure the dependency sorting is updated */
+                       snode->edittree->update |= NTREE_UPDATE_LINKS;
+               }
+               ntreeUpdateTree(snode->edittree);
+               snode_update(snode, node);
        }
+       
+       return OPERATOR_FINISHED;
 }
 
 
 static int node_active_link_viewer(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node;
        
-       node= editnode_get_active(snode->edittree);
+       node = editnode_get_active(snode->edittree);
        
-       if(!node)
+       if (!node)
                return OPERATOR_CANCELLED;
 
        ED_preview_kill_jobs(C);
 
-       node_link_viewer(snode, node);
+       if (node_link_viewer(C, node) == OPERATOR_CANCELLED)
+               return OPERATOR_CANCELLED;
+
        snode_notify(C, snode);
 
        return OPERATOR_FINISHED;
@@ -1734,40 +2188,40 @@ static int node_active_link_viewer(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_link_viewer(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Link to Viewer Node";
+       ot->name = "Link to Viewer Node";
        ot->description = "Link to viewer node";
-       ot->idname= "NODE_OT_link_viewer";
+       ot->idname = "NODE_OT_link_viewer";
        
        /* api callbacks */
-       ot->exec= node_active_link_viewer;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_active_link_viewer;
+       ot->poll = composite_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 
 
 /* return 0, nothing done */
-static int UNUSED_FUNCTION(node_mouse_groupheader)(SpaceNode *snode)
+static int UNUSED_FUNCTION(node_mouse_groupheader) (SpaceNode * snode)
 {
        bNode *gnode;
-       float mx=0, my=0;
+       float mx = 0, my = 0;
 // XXX int mval[2];
        
-       gnode= node_tree_get_editgroup(snode->nodetree);
-       if(gnode==NULL) return 0;
+       gnode = node_tree_get_editgroup(snode->nodetree);
+       if (gnode == NULL) return 0;
        
 // XXX getmouseco_areawin(mval);
 // XXX areamouseco_to_ipoco(G.v2d, mval, &mx, &my);
        
        /* click in header or outside? */
-       if(BLI_in_rctf(&gnode->totr, mx, my)==0) {
-               rctf rect= gnode->totr;
+       if (BLI_in_rctf(&gnode->totr, mx, my) == 0) {
+               rctf rect = gnode->totr;
                
                rect.ymax += NODE_DY;
-               if(BLI_in_rctf(&rect, mx, my)==0)
-                       snode_make_group_editable(snode, NULL); /* toggles, so exits editmode */
+               if (BLI_in_rctf(&rect, mx, my) == 0)
+                       snode_make_group_editable(snode, NULL);  /* toggles, so exits editmode */
 //             else
 // XXX                 transform_nodes(snode->nodetree, 'g', "Move group");
                
@@ -1778,51 +2232,55 @@ static int UNUSED_FUNCTION(node_mouse_groupheader)(SpaceNode *snode)
 
 /* checks snode->mouse position, and returns found node/socket */
 /* type is SOCK_IN and/or SOCK_OUT */
-static int find_indicated_socket(SpaceNode *snode, bNode **nodep, bNodeSocket **sockp, int in_out)
+int node_find_indicated_socket(SpaceNode *snode, bNode **nodep, bNodeSocket **sockp, int in_out)
 {
        bNode *node;
        bNodeSocket *sock;
        rctf rect;
        
+       *nodep = NULL;
+       *sockp = NULL;
+       
        /* check if we click in a socket */
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
                
-               rect.xmin = snode->mx - (NODE_SOCKSIZE+4);
-               rect.ymin = snode->my - (NODE_SOCKSIZE+4);
-               rect.xmax = snode->mx + (NODE_SOCKSIZE+4);
-               rect.ymax = snode->my + (NODE_SOCKSIZE+4);
+               rect.xmin = snode->mx - (NODE_SOCKSIZE + 4);
+               rect.ymin = snode->my - (NODE_SOCKSIZE + 4);
+               rect.xmax = snode->mx + (NODE_SOCKSIZE + 4);
+               rect.ymax = snode->my + (NODE_SOCKSIZE + 4);
                
                if (!(node->flag & NODE_HIDDEN)) {
                        /* extra padding inside and out - allow dragging on the text areas too */
                        if (in_out == SOCK_IN) {
                                rect.xmax += NODE_SOCKSIZE;
-                               rect.xmin -= NODE_SOCKSIZE*4;
-                       } else if (in_out == SOCK_OUT) {
-                               rect.xmax += NODE_SOCKSIZE*4;
+                               rect.xmin -= NODE_SOCKSIZE * 4;
+                       }
+                       else if (in_out == SOCK_OUT) {
+                               rect.xmax += NODE_SOCKSIZE * 4;
                                rect.xmin -= NODE_SOCKSIZE;
                        }
                }
                
-               if(in_out & SOCK_IN) {
-                       for(sock= node->inputs.first; sock; sock= sock->next) {
-                               if(!nodeSocketIsHidden(sock)) {
-                                       if(BLI_in_rctf(&rect, sock->locx, sock->locy)) {
-                                               if(node == visible_node(snode, &rect)) {
-                                                       *nodep= node;
-                                                       *sockp= sock;
+               if (in_out & SOCK_IN) {
+                       for (sock = node->inputs.first; sock; sock = sock->next) {
+                               if (!nodeSocketIsHidden(sock)) {
+                                       if (BLI_in_rctf(&rect, sock->locx, sock->locy)) {
+                                               if (node == visible_node(snode, &rect)) {
+                                                       *nodep = node;
+                                                       *sockp = sock;
                                                        return 1;
                                                }
                                        }
                                }
                        }
                }
-               if(in_out & SOCK_OUT) {
-                       for(sock= node->outputs.first; sock; sock= sock->next) {
-                               if(!nodeSocketIsHidden(sock)) {
-                                       if(BLI_in_rctf(&rect, sock->locx, sock->locy)) {
-                                               if(node == visible_node(snode, &rect)) {
-                                                       *nodep= node;
-                                                       *sockp= sock;
+               if (in_out & SOCK_OUT) {
+                       for (sock = node->outputs.first; sock; sock = sock->next) {
+                               if (!nodeSocketIsHidden(sock)) {
+                                       if (BLI_in_rctf(&rect, sock->locx, sock->locy)) {
+                                               if (node == visible_node(snode, &rect)) {
+                                                       *nodep = node;
+                                                       *sockp = sock;
                                                        return 1;
                                                }
                                        }
@@ -1834,23 +2292,23 @@ static int find_indicated_socket(SpaceNode *snode, bNode **nodep, bNodeSocket **
        /* check group sockets
         * NB: using ngroup->outputs as input sockets and vice versa here!
         */
-       if(in_out & SOCK_IN) {
-               for(sock= snode->edittree->outputs.first; sock; sock= sock->next) {
-                       if(!nodeSocketIsHidden(sock)) {
-                               if(BLI_in_rctf(&rect, sock->locx, sock->locy)) {
-                                       *nodep= NULL;   /* NULL node pointer indicates group socket */
-                                       *sockp= sock;
+       if (in_out & SOCK_IN) {
+               for (sock = snode->edittree->outputs.first; sock; sock = sock->next) {
+                       if (!nodeSocketIsHidden(sock)) {
+                               if (BLI_in_rctf(&rect, sock->locx, sock->locy)) {
+                                       *nodep = NULL;   /* NULL node pointer indicates group socket */
+                                       *sockp = sock;
                                        return 1;
                                }
                        }
                }
        }
-       if(in_out & SOCK_OUT) {
-               for(sock= snode->edittree->inputs.first; sock; sock= sock->next) {
-                       if(!nodeSocketIsHidden(sock)) {
-                               if(BLI_in_rctf(&rect, sock->locx, sock->locy)) {
-                                       *nodep= NULL;   /* NULL node pointer indicates group socket */
-                                       *sockp= sock;
+       if (in_out & SOCK_OUT) {
+               for (sock = snode->edittree->inputs.first; sock; sock = sock->next) {
+                       if (!nodeSocketIsHidden(sock)) {
+                               if (BLI_in_rctf(&rect, sock->locx, sock->locy)) {
+                                       *nodep = NULL;   /* NULL node pointer indicates group socket */
+                                       *sockp = sock;
                                        return 1;
                                }
                        }
@@ -1860,49 +2318,14 @@ static int find_indicated_socket(SpaceNode *snode, bNode **nodep, bNodeSocket **
        return 0;
 }
 
-static int node_socket_hilights(SpaceNode *snode, int in_out)
-{
-       bNode *node;
-       bNodeSocket *sock, *tsock, *socksel= NULL;
-       short redraw= 0;
-       
-       if(snode->edittree==NULL) return 0;
-       
-       /* deselect sockets */
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               for(sock= node->inputs.first; sock; sock= sock->next) {
-                       if(sock->flag & SELECT) {
-                               sock->flag &= ~SELECT;
-                               redraw++;
-                               socksel= sock;
-                       }
-               }
-               for(sock= node->outputs.first; sock; sock= sock->next) {
-                       if(sock->flag & SELECT) {
-                               sock->flag &= ~SELECT;
-                               redraw++;
-                               socksel= sock;
-                       }
-               }
-       }
-       
-       // XXX mousepos should be set here!
-       
-       if(find_indicated_socket(snode, &node, &tsock, in_out)) {
-               tsock->flag |= SELECT;
-               if(redraw==1 && tsock==socksel) redraw= 0;
-               else redraw= 1;
-       }
-       
-       return redraw;
-}
-
 static int outside_group_rect(SpaceNode *snode)
 {
-       bNode *gnode= node_tree_get_editgroup(snode->nodetree);
+       bNode *gnode = node_tree_get_editgroup(snode->nodetree);
        if (gnode) {
-               return (snode->mx < gnode->totr.xmin || snode->mx >= gnode->totr.xmax
-                               || snode->my < gnode->totr.ymin || snode->my >= gnode->totr.ymax);
+               return (snode->mx <  gnode->totr.xmin ||
+                       snode->mx >= gnode->totr.xmax ||
+                       snode->my <  gnode->totr.ymin ||
+                       snode->my >= gnode->totr.ymax);
        }
        return 0;
 }
@@ -1943,21 +2366,29 @@ static bNodeSocket *best_socket_output(bNodeTree *ntree, bNode *node, bNodeSocke
 {
        bNodeSocket *sock;
        
-       /* first try to find a socket with a matching name */
-       for (sock=node->outputs.first; sock; sock=sock->next) {
-
+       /* first look for selected output */
+       for (sock = node->outputs.first; sock; sock = sock->next) {
+               if (!socket_is_available(ntree, sock, allow_multiple))
+                       continue;
+               
+               if (sock->flag & SELECT)
+                       return sock;
+       }
+       
+       /* try to find a socket with a matching name */
+       for (sock = node->outputs.first; sock; sock = sock->next) {
                if (!socket_is_available(ntree, sock, allow_multiple))
                        continue;
 
                /* check for same types */
                if (sock->type == sock_target->type) {
-                       if (strcmp(sock->name, sock_target->name)==0)
+                       if (strcmp(sock->name, sock_target->name) == 0)
                                return sock;
                }
        }
        
        /* otherwise settle for the first available socket of the right type */
-       for (sock=node->outputs.first; sock; sock=sock->next) {
+       for (sock = node->outputs.first; sock; sock = sock->next) {
 
                if (!socket_is_available(ntree, sock, allow_multiple))
                        continue;
@@ -1971,21 +2402,21 @@ static bNodeSocket *best_socket_output(bNodeTree *ntree, bNode *node, bNodeSocke
        return NULL;
 }
 
-/* this is a bit complicated, but designed to prioritise finding 
+/* this is a bit complicated, but designed to prioritize finding
  * sockets of higher types, such as image, first */
 static bNodeSocket *best_socket_input(bNodeTree *ntree, bNode *node, int num, int replace)
 {
        bNodeSocket *sock;
-       int socktype, maxtype=0;
+       int socktype, maxtype = 0;
        int a = 0;
        
-       for (sock=node->inputs.first; sock; sock=sock->next) {
+       for (sock = node->inputs.first; sock; sock = sock->next) {
                maxtype = MAX2(sock->type, maxtype);
        }
        
        /* find sockets of higher 'types' first (i.e. image) */
-       for (socktype=maxtype; socktype >= 0; socktype--) {
-               for (sock=node->inputs.first; sock; sock=sock->next) {
+       for (socktype = maxtype; socktype >= 0; socktype--) {
+               for (sock = node->inputs.first; sock; sock = sock->next) {
                        
                        if (!socket_is_available(ntree, sock, replace)) {
                                a++;
@@ -2005,16 +2436,37 @@ static bNodeSocket *best_socket_input(bNodeTree *ntree, bNode *node, int num, in
        return NULL;
 }
 
+static int snode_autoconnect_input(SpaceNode *snode, bNode *node_fr, bNodeSocket *sock_fr, bNode *node_to, bNodeSocket *sock_to, int replace)
+{
+       bNodeTree *ntree = snode->edittree;
+       bNodeLink *link;
+       
+       /* then we can connect */
+       if (replace)
+               nodeRemSocketLinks(ntree, sock_to);
+       
+       link = nodeAddLink(ntree, node_fr, sock_fr, node_to, sock_to);
+       /* validate the new link */
+       ntreeUpdateTree(ntree);
+       if (!(link->flag & NODE_LINK_VALID)) {
+               nodeRemLink(ntree, link);
+               return 0;
+       }
+       
+       snode_update(snode, node_to);
+       return 1;
+}
+
 void snode_autoconnect(SpaceNode *snode, int allow_multiple, int replace)
 {
+       bNodeTree *ntree = snode->edittree;
        ListBase *nodelist = MEM_callocN(sizeof(ListBase), "items_list");
        bNodeListItem *nli;
        bNode *node;
-       bNodeLink *link;
-       int i, numlinks=0;
+       int i, numlinks = 0;
        
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & NODE_SELECT) {
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & NODE_SELECT) {
                        nli = MEM_mallocN(sizeof(bNodeListItem), "temporary node list item");
                        nli->node = node;
                        BLI_addtail(nodelist, nli);
@@ -2024,46 +2476,60 @@ void snode_autoconnect(SpaceNode *snode, int allow_multiple, int replace)
        /* sort nodes left to right */
        BLI_sortlist(nodelist, sort_nodes_locx);
        
-       for (nli=nodelist->first; nli; nli=nli->next) {
+       for (nli = nodelist->first; nli; nli = nli->next) {
                bNode *node_fr, *node_to;
                bNodeSocket *sock_fr, *sock_to;
+               int has_selected_inputs = 0;
                
                if (nli->next == NULL) break;
                
                node_fr = nli->node;
                node_to = nli->next->node;
                
-               /* check over input sockets first */
-               for (i=0; i<BLI_countlist(&node_to->inputs); i++) {
-                       
-                       /* find the best guess input socket */
-                       sock_to = best_socket_input(snode->edittree, node_to, i, replace);
-                       if (!sock_to) continue;
-                       
-                       /* check for an appropriate output socket to connect from */
-                       sock_fr = best_socket_output(snode->edittree, node_fr, sock_to, allow_multiple);
-                       if (!sock_fr) continue;
-                       
-                       /* then we can connect */
-                       if (replace)
-                               nodeRemSocketLinks(snode->edittree, sock_to);
-                       
-                       link = nodeAddLink(snode->edittree, node_fr, sock_fr, node_to, sock_to);
-                       /* validate the new link */
-                       ntreeUpdateTree(snode->edittree);
-                       if (!(link->flag & NODE_LINK_VALID)) {
-                               nodeRemLink(snode->edittree, link);
-                               continue;
+               /* if there are selected sockets, connect those */
+               for (sock_to = node_to->inputs.first; sock_to; sock_to = sock_to->next) {
+                       if (sock_to->flag & SELECT) {
+                               has_selected_inputs = 1;
+                               
+                               if (!socket_is_available(ntree, sock_to, replace))
+                                       continue;
+                               
+                               /* check for an appropriate output socket to connect from */
+                               sock_fr = best_socket_output(ntree, node_fr, sock_to, allow_multiple);
+                               if (!sock_fr)
+                                       continue;
+       
+                               if (snode_autoconnect_input(snode, node_fr, sock_fr, node_to, sock_to, replace))
+                                       ++numlinks;
                        }
+               }
+               
+               if (!has_selected_inputs) {
+                       /* no selected inputs, connect by finding suitable match */
+                       int num_inputs = BLI_countlist(&node_to->inputs);
                        
-                       snode_update(snode, node_to);
-                       ++numlinks;
-                       break;
+                       for (i = 0; i < num_inputs; i++) {
+                               
+                               /* find the best guess input socket */
+                               sock_to = best_socket_input(ntree, node_to, i, replace);
+                               if (!sock_to)
+                                       continue;
+                               
+                               /* check for an appropriate output socket to connect from */
+                               sock_fr = best_socket_output(ntree, node_fr, sock_to, allow_multiple);
+                               if (!sock_fr)
+                                       continue;
+       
+                               if (snode_autoconnect_input(snode, node_fr, sock_fr, node_to, sock_to, replace)) {
+                                       ++numlinks;
+                                       break;
+                               }
+                       }
                }
        }
        
        if (numlinks > 0) {
-               ntreeUpdateTree(snode->edittree);
+               ntreeUpdateTree(ntree);
        }
        
        BLI_freelistN(nodelist);
@@ -2073,45 +2539,47 @@ void snode_autoconnect(SpaceNode *snode, int allow_multiple, int replace)
 /* can be called from menus too, but they should do own undopush and redraws */
 bNode *node_add_node(SpaceNode *snode, Main *bmain, Scene *scene, bNodeTemplate *ntemp, float locx, float locy)
 {
-       bNode *node= NULL, *gnode;
+       bNode *node = NULL, *gnode;
        
        node_deselect_all(snode);
        
        node = nodeAddNode(snode->edittree, ntemp);
        
        /* generics */
-       if(node) {
-               node->locx= locx;
-               node->locy= locy + 60.0f;               // arbitrary.. so its visible, (0,0) is top of node
-               node->flag |= SELECT;
+       if (node) {
+               node_select(node);
                
-               gnode= node_tree_get_editgroup(snode->nodetree);
-               if(gnode) {
-                       node->locx -= gnode->locx;
-                       node->locy -= gnode->locy;
+               gnode = node_tree_get_editgroup(snode->nodetree);
+               // arbitrary y offset of 60 so its visible
+               if (gnode) {
+                       nodeFromView(gnode, locx, locy + 60.0f, &node->locx, &node->locy);
+               }
+               else {
+                       node->locx = locx;
+                       node->locy = locy + 60.0f;
                }
 
                ntreeUpdateTree(snode->edittree);
                ED_node_set_active(bmain, snode->edittree, node);
                
-               if(snode->nodetree->type==NTREE_COMPOSIT) {
-                       if(ELEM4(node->type, CMP_NODE_R_LAYERS, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE)) {
+               if (snode->nodetree->type == NTREE_COMPOSIT) {
+                       if (ELEM4(node->type, CMP_NODE_R_LAYERS, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE)) {
                                node->id = &scene->id;
                        }
-                       else if(ELEM3(node->type, CMP_NODE_MOVIECLIP, CMP_NODE_MOVIEDISTORTION, CMP_NODE_STABILIZE2D)) {
+                       else if (ELEM3(node->type, CMP_NODE_MOVIECLIP, CMP_NODE_MOVIEDISTORTION, CMP_NODE_STABILIZE2D)) {
                                node->id = (ID *)scene->clip;
                        }
                        
                        ntreeCompositForceHidden(snode->edittree, scene);
                }
                        
-               if(node->id)
+               if (node->id)
                        id_us_plus(node->id);
                        
                snode_update(snode, node);
        }
        
-       if(snode->nodetree->type==NTREE_TEXTURE) {
+       if (snode->nodetree->type == NTREE_TEXTURE) {
                ntreeTexCheckCyclics(snode->edittree);
        }
        
@@ -2120,10 +2588,31 @@ bNode *node_add_node(SpaceNode *snode, Main *bmain, Scene *scene, bNodeTemplate
 
 /* ****************** Duplicate *********************** */
 
+static void node_duplicate_reparent_recursive(bNode *node)
+{
+       bNode *parent;
+       
+       node->flag |= NODE_TEST;
+       
+       /* find first selected parent */
+       for (parent = node->parent; parent; parent = parent->parent) {
+               if (parent->flag & SELECT) {
+                       if (!(parent->flag & NODE_TEST))
+                               node_duplicate_reparent_recursive(parent);
+                       break;
+               }
+       }
+       /* reparent node copy to parent copy */
+       if (parent) {
+               nodeDetachNode(node->new_node);
+               nodeAttachNode(node->new_node, parent->new_node);
+       }
+}
+
 static int node_duplicate_exec(bContext *C, wmOperator *op)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       bNodeTree *ntree= snode->edittree;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
        bNode *node, *newnode, *lastnode;
        bNodeLink *link, *newlink, *lastlink;
        int keep_inputs = RNA_boolean_get(op->ptr, "keep_inputs");
@@ -2131,12 +2620,12 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
        ED_preview_kill_jobs(C);
        
        lastnode = ntree->nodes.last;
-       for(node= ntree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
                        newnode = nodeCopyNode(ntree, node);
                        
-                       if(newnode->id) {
-                               /* simple id user adjustment, node internal functions dont touch this
+                       if (newnode->id) {
+                               /* simple id user adjustment, node internal functions don't touch this
                                 * but operators and readfile.c do. */
                                id_us_plus(newnode->id);
                                /* to ensure redraws or rerenders happen */
@@ -2145,7 +2634,7 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
                }
                
                /* make sure we don't copy new nodes again! */
-               if (node==lastnode)
+               if (node == lastnode)
                        break;
        }
        
@@ -2153,12 +2642,13 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
         * NB: this depends on correct node->new_node and sock->new_sock pointers from above copy!
         */
        lastlink = ntree->links.last;
-       for (link=ntree->links.first; link; link=link->next) {
+       for (link = ntree->links.first; link; link = link->next) {
                /* This creates new links between copied nodes.
                 * If keep_inputs is set, also copies input links from unselected (when fromnode==NULL)!
                 */
-               if (link->tonode && (link->tonode->flag & NODE_SELECT)
-                       && (keep_inputs || (link->fromnode && (link->fromnode->flag & NODE_SELECT)))) {
+               if (link->tonode && (link->tonode->flag & NODE_SELECT) &&
+                   (keep_inputs || (link->fromnode && (link->fromnode->flag & NODE_SELECT))))
+               {
                        newlink = MEM_callocN(sizeof(bNodeLink), "bNodeLink");
                        newlink->flag = link->flag;
                        newlink->tonode = link->tonode->new_node;
@@ -2177,22 +2667,36 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
                }
                
                /* make sure we don't copy new links again! */
-               if (link==lastlink)
+               if (link == lastlink)
+                       break;
+       }
+       
+       /* clear flags for recursive depth-first iteration */
+       for (node = ntree->nodes.first; node; node = node->next)
+               node->flag &= ~NODE_TEST;
+       /* reparent copied nodes */
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if ((node->flag & SELECT) && !(node->flag & NODE_TEST))
+                       node_duplicate_reparent_recursive(node);
+               
+               /* only has to check old nodes */
+               if (node == lastnode)
                        break;
        }
        
        /* deselect old nodes, select the copies instead */
-       for(node= ntree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
                        /* has been set during copy above */
                        newnode = node->new_node;
                        
-                       node->flag &= ~(NODE_SELECT|NODE_ACTIVE);
-                       newnode->flag |= NODE_SELECT;
+                       node_deselect(node);
+                       node->flag &= ~NODE_ACTIVE;
+                       node_select(newnode);
                }
                
                /* make sure we don't copy new nodes again! */
-               if (node==lastnode)
+               if (node == lastnode)
                        break;
        }
        
@@ -2207,16 +2711,16 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
 void NODE_OT_duplicate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Duplicate Nodes";
+       ot->name = "Duplicate Nodes";
        ot->description = "Duplicate selected nodes";
-       ot->idname= "NODE_OT_duplicate";
+       ot->idname = "NODE_OT_duplicate";
        
        /* api callbacks */
-       ot->exec= node_duplicate_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_duplicate_exec;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "keep_inputs", 0, "Keep Inputs", "Keep the input links to duplicated nodes");
 }
@@ -2228,24 +2732,24 @@ static void node_remove_extra_links(SpaceNode *snode, bNodeSocket *tsock, bNodeL
        bNodeLink *tlink;
        bNodeSocket *sock;
        
-       if(tsock && nodeCountSocketLinks(snode->edittree, link->tosock) > tsock->limit) {
+       if (tsock && nodeCountSocketLinks(snode->edittree, link->tosock) > tsock->limit) {
                
-               for(tlink= snode->edittree->links.first; tlink; tlink= tlink->next) {
-                       if(link!=tlink && tlink->tosock==link->tosock)
+               for (tlink = snode->edittree->links.first; tlink; tlink = tlink->next) {
+                       if (link != tlink && tlink->tosock == link->tosock)
                                break;
                }
-               if(tlink) {
+               if (tlink) {
                        /* try to move the existing link to the next available socket */
                        if (tlink->tonode) {
                                /* is there a free input socket with the target type? */
-                               for(sock= tlink->tonode->inputs.first; sock; sock= sock->next) {
-                                       if(sock->type==tlink->tosock->type)
-                                               if(nodeCountSocketLinks(snode->edittree, sock) < sock->limit)
+                               for (sock = tlink->tonode->inputs.first; sock; sock = sock->next) {
+                                       if (sock->type == tlink->tosock->type)
+                                               if (nodeCountSocketLinks(snode->edittree, sock) < sock->limit)
                                                        break;
                                }
-                               if(sock) {
-                                       tlink->tosock= sock;
-                                       sock->flag &= ~(SOCK_HIDDEN|SOCK_AUTO_HIDDEN);
+                               if (sock) {
+                                       tlink->tosock = sock;
+                                       sock->flag &= ~SOCK_HIDDEN;
                                }
                                else {
                                        nodeRemLink(snode->edittree, tlink);
@@ -2253,6 +2757,8 @@ static void node_remove_extra_links(SpaceNode *snode, bNodeSocket *tsock, bNodeL
                        }
                        else
                                nodeRemLink(snode->edittree, tlink);
+                       
+                       snode->edittree->update |= NTREE_UPDATE_LINKS;
                }
        }
 }
@@ -2261,218 +2767,273 @@ static void node_remove_extra_links(SpaceNode *snode, bNodeSocket *tsock, bNodeL
 /* in_out = starting socket */
 static int node_link_modal(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       bNodeLinkDrag *nldrag= op->customdata;
-       bNode *tnode, *node;
-       bNodeSocket *tsock= NULL, *sock;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       bNodeLinkDrag *nldrag = op->customdata;
+       bNodeTree *ntree = snode->edittree;
+       bNode *tnode;
+       bNodeSocket *tsock = NULL;
        bNodeLink *link;
+       LinkData *linkdata;
        int in_out;
 
-       in_out= nldrag->in_out;
-       node= nldrag->node;
-       sock= nldrag->sock;
-       link= nldrag->link;
+       in_out = nldrag->in_out;
        
        UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1],
-                                                        &snode->mx, &snode->my);
+                                &snode->mx, &snode->my);
 
        switch (event->type) {
                case MOUSEMOVE:
                        
-                       if(in_out==SOCK_OUT) {
-                               if(find_indicated_socket(snode, &tnode, &tsock, SOCK_IN)) {
-                                       if(nodeFindLink(snode->edittree, sock, tsock)==NULL) {
-                                               if( link->tosock!= tsock && (!tnode || (tnode!=node && link->tonode!=tnode)) ) {
-                                                       link->tonode= tnode;
-                                                       link->tosock= tsock;
-                                                       if (link->prev==NULL && link->next==NULL) {
-                                                               BLI_addtail(&snode->edittree->links, link);
-                                                       }
-                                                       
-                                                       snode->edittree->update |= NTREE_UPDATE_LINKS;
-                                                       ntreeUpdateTree(snode->edittree);
-                                               }
+                       if (in_out == SOCK_OUT) {
+                               if (node_find_indicated_socket(snode, &tnode, &tsock, SOCK_IN)) {
+                                       for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) {
+                                               link = linkdata->data;
+                                               
+                                               /* skip if this is already the target socket */
+                                               if (link->tosock == tsock)
+                                                       continue;
+                                               /* skip if socket is on the same node as the fromsock */
+                                               if (tnode && link->fromnode == tnode)
+                                                       continue;
+                                               
+                                               /* attach links to the socket */
+                                               link->tonode = tnode;
+                                               link->tosock = tsock;
+                                               /* add it to the node tree temporarily */
+                                               if (BLI_findindex(&ntree->links, link) < 0)
+                                                       BLI_addtail(&ntree->links, link);
+                                               
+                                               ntree->update |= NTREE_UPDATE_LINKS;
                                        }
+                                       ntreeUpdateTree(ntree);
                                }
                                else {
-                                       if (link->tonode || link->tosock) {
-                                               BLI_remlink(&snode->edittree->links, link);
-                                               link->prev = link->next = NULL;
-                                               link->tonode= NULL;
-                                               link->tosock= NULL;
+                                       int do_update = FALSE;
+                                       for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) {
+                                               link = linkdata->data;
                                                
-                                               snode->edittree->update |= NTREE_UPDATE_LINKS;
-                                               ntreeUpdateTree(snode->edittree);
+                                               if (link->tonode || link->tosock) {
+                                                       BLI_remlink(&ntree->links, link);
+                                                       link->prev = link->next = NULL;
+                                                       link->tonode = NULL;
+                                                       link->tosock = NULL;
+                                                       
+                                                       ntree->update |= NTREE_UPDATE_LINKS;
+                                                       do_update = TRUE;
+                                               }
+                                       }
+                                       if (do_update) {
+                                               ntreeUpdateTree(ntree);
                                        }
                                }
                        }
                        else {
-                               if(find_indicated_socket(snode, &tnode, &tsock, SOCK_OUT)) {
-                                       if(nodeFindLink(snode->edittree, sock, tsock)==NULL) {
-                                               if(nodeCountSocketLinks(snode->edittree, tsock) < tsock->limit) {
-                                                       if( link->fromsock!= tsock && (!tnode || (tnode!=node && link->fromnode!=tnode)) ) {
-                                                               link->fromnode= tnode;
-                                                               link->fromsock= tsock;
-                                                               if (link->prev==NULL && link->next==NULL) {
-                                                                       BLI_addtail(&snode->edittree->links, link);
-                                                               }
-                                                               
-                                                               snode->edittree->update |= NTREE_UPDATE_LINKS;
-                                                               ntreeUpdateTree(snode->edittree);
-                                                       }
-                                               }
+                               if (node_find_indicated_socket(snode, &tnode, &tsock, SOCK_OUT)) {
+                                       for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) {
+                                               link = linkdata->data;
+                                               
+                                               /* skip if this is already the target socket */
+                                               if (link->fromsock == tsock)
+                                                       continue;
+                                               /* skip if socket is on the same node as the fromsock */
+                                               if (tnode && link->tonode == tnode)
+                                                       continue;
+                                               
+                                               /* attach links to the socket */
+                                               link->fromnode = tnode;
+                                               link->fromsock = tsock;
+                                               /* add it to the node tree temporarily */
+                                               if (BLI_findindex(&ntree->links, link) < 0)
+                                                       BLI_addtail(&ntree->links, link);
+                                               
+                                               ntree->update |= NTREE_UPDATE_LINKS;
                                        }
+                                       ntreeUpdateTree(ntree);
                                }
                                else {
-                                       if (link->tonode || link->tosock) {
-                                               BLI_remlink(&snode->edittree->links, link);
-                                               link->prev = link->next = NULL;
-                                               link->fromnode= NULL;
-                                               link->fromsock= NULL;
-                                               snode->edittree->update |= NTREE_UPDATE_LINKS;
-                                               ntreeUpdateTree(snode->edittree);
+                                       int do_update = FALSE;
+                                       for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) {
+                                               link = linkdata->data;
+                                               
+                                               if (link->fromnode || link->fromsock) {
+                                                       BLI_remlink(&ntree->links, link);
+                                                       link->prev = link->next = NULL;
+                                                       link->fromnode = NULL;
+                                                       link->fromsock = NULL;
+                                                       
+                                                       ntree->update |= NTREE_UPDATE_LINKS;
+                                                       do_update = TRUE;
+                                               }
+                                       }
+                                       if (do_update) {
+                                               ntreeUpdateTree(ntree);
                                        }
                                }
                        }
-                       /* hilight target sockets only */
-                       node_socket_hilights(snode, in_out==SOCK_OUT?SOCK_IN:SOCK_OUT);
+                       
                        ED_region_tag_redraw(ar);
                        break;
                        
                case LEFTMOUSE:
                case RIGHTMOUSE:
-               case MIDDLEMOUSE:
-                       if(link->tosock && link->fromsock) {
-                               /* send changed events for original tonode and new */
-                               snode_update(snode, link->tonode);
+               case MIDDLEMOUSE: {
+                       for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) {
+                               link = linkdata->data;
                                
-                               /* we might need to remove a link */
-                               if(in_out==SOCK_OUT)
-                                       node_remove_extra_links(snode, link->tosock, link);
-                               
-                               /* when linking to group outputs, update the socket type */
-                               /* XXX this should all be part of a generic update system */
-                               if (!link->tonode) {
-                                       link->tosock->type = link->fromsock->type;
-                               }
-                       }
-                       else if (outside_group_rect(snode) && (link->tonode || link->fromnode)) {
-                               /* automatically add new group socket */
-                               if (link->tonode && link->tosock) {
-                                       link->fromsock = node_group_expose_socket(snode->edittree, link->tosock, SOCK_IN);
-                                       link->fromnode = NULL;
-                                       if (link->prev==NULL && link->next==NULL) {
-                                               BLI_addtail(&snode->edittree->links, link);
+                               if (link->tosock && link->fromsock) {
+                                       /* send changed events for original tonode and new */
+                                       if (link->tonode)
+                                               snode_update(snode, link->tonode);
+                                       
+                                       /* we might need to remove a link */
+                                       if (in_out == SOCK_OUT)
+                                               node_remove_extra_links(snode, link->tosock, link);
+                                       
+                                       /* when linking to group outputs, update the socket type */
+                                       /* XXX this should all be part of a generic update system */
+                                       if (!link->tonode) {
+                                               if (link->tosock->type != link->fromsock->type)
+                                                       nodeSocketSetType(link->tosock, link->fromsock->type);
                                        }
-                                       snode->edittree->update |= NTREE_UPDATE_GROUP_IN | NTREE_UPDATE_LINKS;
                                }
-                               else if (link->fromnode && link->fromsock) {
-                                       link->tosock = node_group_expose_socket(snode->edittree, link->fromsock, SOCK_OUT);
-                                       link->tonode = NULL;
-                                       if (link->prev==NULL && link->next==NULL) {
-                                               BLI_addtail(&snode->edittree->links, link);
+                               else if (outside_group_rect(snode) && (link->tonode || link->fromnode)) {
+                                       /* automatically add new group socket */
+                                       if (link->tonode && link->tosock) {
+                                               link->fromsock = node_group_expose_socket(ntree, link->tosock, SOCK_IN);
+                                               link->fromnode = NULL;
+                                               if (BLI_findindex(&ntree->links, link) < 0)
+                                                       BLI_addtail(&ntree->links, link);
+                                               
+                                               ntree->update |= NTREE_UPDATE_GROUP_IN | NTREE_UPDATE_LINKS;
+                                       }
+                                       else if (link->fromnode && link->fromsock) {
+                                               link->tosock = node_group_expose_socket(ntree, link->fromsock, SOCK_OUT);
+                                               link->tonode = NULL;
+                                               if (BLI_findindex(&ntree->links, link) < 0)
+                                                       BLI_addtail(&ntree->links, link);
+                                               
+                                               ntree->update |= NTREE_UPDATE_GROUP_OUT | NTREE_UPDATE_LINKS;
                                        }
-                                       snode->edittree->update |= NTREE_UPDATE_GROUP_OUT | NTREE_UPDATE_LINKS;
                                }
+                               else
+                                       nodeRemLink(ntree, link);
                        }
-                       else
-                               nodeRemLink(snode->edittree, link);
                        
-                       ntreeUpdateTree(snode->edittree);
+                       ntreeUpdateTree(ntree);
                        snode_notify(C, snode);
                        snode_dag_update(C, snode);
                        
                        BLI_remlink(&snode->linkdrag, nldrag);
+                       /* links->data pointers are either held by the tree or freed already */
+                       BLI_freelistN(&nldrag->links);
                        MEM_freeN(nldrag);
                        
                        return OPERATOR_FINISHED;
+               }
        }
        
        return OPERATOR_RUNNING_MODAL;
 }
 
 /* return 1 when socket clicked */
-static int node_link_init(SpaceNode *snode, bNodeLinkDrag *nldrag)
+static bNodeLinkDrag *node_link_init(SpaceNode *snode, int detach)
 {
-       bNodeLink *link;
-
+       bNode *node;
+       bNodeSocket *sock;
+       bNodeLink *link, *link_next, *oplink;
+       bNodeLinkDrag *nldrag = NULL;
+       LinkData *linkdata;
+       int num_links;
+       
        /* output indicated? */
-       if(find_indicated_socket(snode, &nldrag->node, &nldrag->sock, SOCK_OUT)) {
-               if(nodeCountSocketLinks(snode->edittree, nldrag->sock) < nldrag->sock->limit)
-                       return SOCK_OUT;
-               else {
-                       /* find if we break a link */
-                       for(link= snode->edittree->links.first; link; link= link->next) {
-                               if(link->fromsock==nldrag->sock)
-                                       break;
-                       }
-                       if(link) {
-                               nldrag->node= link->tonode;
-                               nldrag->sock= link->tosock;
-                               nodeRemLink(snode->edittree, link);
-                               return SOCK_IN;
+       if (node_find_indicated_socket(snode, &node, &sock, SOCK_OUT)) {
+               nldrag = MEM_callocN(sizeof(bNodeLinkDrag), "drag link op customdata");
+               
+               num_links = nodeCountSocketLinks(snode->edittree, sock);
+               if (num_links > 0 && (num_links >= sock->limit || detach)) {
+                       /* dragged links are fixed on input side */
+                       nldrag->in_out = SOCK_IN;
+                       /* detach current links and store them in the operator data */
+                       for (link = snode->edittree->links.first; link; link = link_next) {
+                               link_next = link->next;
+                               if (link->fromsock == sock) {
+                                       linkdata = MEM_callocN(sizeof(LinkData), "drag link op link data");
+                                       linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link");
+                                       *oplink = *link;
+                                       oplink->next = oplink->prev = NULL;
+                                       BLI_addtail(&nldrag->links, linkdata);
+                                       nodeRemLink(snode->edittree, link);
+                               }
                        }
                }
+               else {
+                       /* dragged links are fixed on output side */
+                       nldrag->in_out = SOCK_OUT;
+                       /* create a new link */
+                       linkdata = MEM_callocN(sizeof(LinkData), "drag link op link data");
+                       linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link");
+                       oplink->fromnode = node;
+                       oplink->fromsock = sock;
+                       BLI_addtail(&nldrag->links, linkdata);
+               }
        }
        /* or an input? */
-       else if(find_indicated_socket(snode, &nldrag->node, &nldrag->sock, SOCK_IN)) {
-               if(nodeCountSocketLinks(snode->edittree, nldrag->sock) < nldrag->sock->limit)
-                       return SOCK_IN;
-               else {
-                       /* find if we break a link */
-                       for(link= snode->edittree->links.first; link; link= link->next) {
-                               if(link->tosock==nldrag->sock)
-                                       break;
-                       }
-                       if(link) {
-                               /* send changed event to original tonode */
-                               if(link->tonode) 
-                                       snode_update(snode, link->tonode);
-                               
-                               nldrag->node= link->fromnode;
-                               nldrag->sock= link->fromsock;
-                               nodeRemLink(snode->edittree, link);
-                               return SOCK_OUT;
+       else if (node_find_indicated_socket(snode, &node, &sock, SOCK_IN)) {
+               nldrag = MEM_callocN(sizeof(bNodeLinkDrag), "drag link op customdata");
+               
+               num_links = nodeCountSocketLinks(snode->edittree, sock);
+               if (num_links > 0 && (num_links >= sock->limit || detach)) {
+                       /* dragged links are fixed on output side */
+                       nldrag->in_out = SOCK_OUT;
+                       /* detach current links and store them in the operator data */
+                       for (link = snode->edittree->links.first; link; link = link_next) {
+                               link_next = link->next;
+                               if (link->tosock == sock) {
+                                       linkdata = MEM_callocN(sizeof(LinkData), "drag link op link data");
+                                       linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link");
+                                       *oplink = *link;
+                                       oplink->next = oplink->prev = NULL;
+                                       BLI_addtail(&nldrag->links, linkdata);
+                                       nodeRemLink(snode->edittree, link);
+                                       
+                                       /* send changed event to original link->tonode */
+                                       if (node)
+                                               snode_update(snode, node);
+                               }
                        }
                }
+               else {
+                       /* dragged links are fixed on input side */
+                       nldrag->in_out = SOCK_IN;
+                       /* create a new link */
+                       linkdata = MEM_callocN(sizeof(LinkData), "drag link op link data");
+                       linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link");
+                       oplink->tonode = node;
+                       oplink->tosock = sock;
+                       BLI_addtail(&nldrag->links, linkdata);
+               }
        }
        
-       return 0;
+       return nldrag;
 }
 
 static int node_link_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
-       bNodeLinkDrag *nldrag= MEM_callocN(sizeof(bNodeLinkDrag), "drag link op customdata");
-       
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       bNodeLinkDrag *nldrag;
+       int detach = RNA_boolean_get(op->ptr, "detach");
        
        UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1],
-                                                        &snode->mx, &snode->my);
+                                &snode->mx, &snode->my);
 
        ED_preview_kill_jobs(C);
 
-       nldrag->in_out= node_link_init(snode, nldrag);
+       nldrag = node_link_init(snode, detach);
        
-       if(nldrag->in_out) {
-               op->customdata= nldrag;
-               
-               /* we make a temporal link */
-               if(nldrag->in_out==SOCK_OUT) {
-                       nldrag->link= MEM_callocN(sizeof(bNodeLink), "link");
-                       nldrag->link->fromnode= nldrag->node;
-                       nldrag->link->fromsock= nldrag->sock;
-                       nldrag->link->tonode= NULL;
-                       nldrag->link->tosock= NULL;
-               }
-               else {
-                       nldrag->link= MEM_callocN(sizeof(bNodeLink), "link");
-                       nldrag->link->fromnode= NULL;
-                       nldrag->link->fromsock= NULL;
-                       nldrag->link->tonode= nldrag->node;
-                       nldrag->link->tosock= nldrag->sock;
-               }
+       if (nldrag) {
+               op->customdata = nldrag;
                BLI_addtail(&snode->linkdrag, nldrag);
                
                /* add modal handler */
@@ -2480,39 +3041,41 @@ static int node_link_invoke(bContext *C, wmOperator *op, wmEvent *event)
                
                return OPERATOR_RUNNING_MODAL;
        }
-       else {
-               MEM_freeN(nldrag);
-               return OPERATOR_CANCELLED|OPERATOR_PASS_THROUGH;
-       }
+       else
+               return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
 }
 
 static int node_link_cancel(bContext *C, wmOperator *op)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       bNodeLinkDrag *nldrag= op->customdata;
-
-       nodeRemLink(snode->edittree, nldrag->link);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeLinkDrag *nldrag = op->customdata;
+       
        BLI_remlink(&snode->linkdrag, nldrag);
+       
+       BLI_freelistN(&nldrag->links);
        MEM_freeN(nldrag);
-
+       
        return OPERATOR_CANCELLED;
 }
 
 void NODE_OT_link(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Link Nodes";
-       ot->idname= "NODE_OT_link";
+       ot->name = "Link Nodes";
+       ot->idname = "NODE_OT_link";
+       ot->description = "Use the mouse to create a link between two nodes";
        
        /* api callbacks */
-       ot->invoke= node_link_invoke;
-       ot->modal= node_link_modal;
-//     ot->exec= node_link_exec;
-       ot->poll= ED_operator_node_active;
-       ot->cancel= node_link_cancel;
+       ot->invoke = node_link_invoke;
+       ot->modal = node_link_modal;
+//     ot->exec = node_link_exec;
+       ot->poll = ED_operator_node_active;
+       ot->cancel = node_link_cancel;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
+       
+       RNA_def_boolean(ot->srna, "detach", FALSE, "Detach", "Detach and redirect existing links");
 }
 
 /* ********************** Make Link operator ***************** */
@@ -2520,13 +3083,17 @@ void NODE_OT_link(wmOperatorType *ot)
 /* makes a link between selected output and input sockets */
 static int node_make_link_exec(bContext *C, wmOperator *op)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        int replace = RNA_boolean_get(op->ptr, "replace");
 
        ED_preview_kill_jobs(C);
 
        snode_autoconnect(snode, 1, replace);
 
+       /* deselect sockets after linking */
+       node_deselect_all_input_sockets(snode, 0);
+       node_deselect_all_output_sockets(snode, 0);
+
        ntreeUpdateTree(snode->edittree);
        snode_notify(C, snode);
        snode_dag_update(C, snode);
@@ -2537,33 +3104,136 @@ static int node_make_link_exec(bContext *C, wmOperator *op)
 void NODE_OT_link_make(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Make Links";
-       ot->description= "Makes a link between selected output in input sockets";
-       ot->idname= "NODE_OT_link_make";
+       ot->name = "Make Links";
+       ot->description = "Makes a link between selected output in input sockets";
+       ot->idname = "NODE_OT_link_make";
        
        /* callbacks */
-       ot->exec= node_make_link_exec;
-       ot->poll= ED_operator_node_active; // XXX we need a special poll which checks that there are selected input/output sockets
+       ot->exec = node_make_link_exec;
+       ot->poll = ED_operator_node_active; // XXX we need a special poll which checks that there are selected input/output sockets
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "replace", 0, "Replace", "Replace socket connections with the new links");
 }
 
-/* ********************** Cut Link operator ***************** */
-
+/* ********************** Add reroute operator ***************** */
 #define LINK_RESOL 12
+static int add_reroute_intersect_check(bNodeLink *link, float mcoords[][2], int tot, float result[2])
+{
+       float coord_array[LINK_RESOL + 1][2];
+       int i, b;
+
+       if (node_link_bezier_points(NULL, NULL, link, coord_array, LINK_RESOL)) {
+
+               for (i = 0; i < tot - 1; i++)
+                       for (b = 0; b < LINK_RESOL; b++)
+                               if (isect_line_line_v2(mcoords[i], mcoords[i + 1], coord_array[b], coord_array[b + 1]) > 0) {
+                                       result[0] = (mcoords[i][0] + mcoords[i + 1][0]) / 2.0f;
+                                       result[1] = (mcoords[i][1] + mcoords[i + 1][1]) / 2.0f;
+                                       return 1;
+                               }
+       }
+       return 0;
+}
+
+static int add_reroute_exec(bContext *C, wmOperator *op)
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       bNode *gnode = node_tree_get_editgroup(snode->nodetree);
+       float mcoords[256][2];
+       int i = 0;
+
+       RNA_BEGIN(op->ptr, itemptr, "path")
+       {
+               float loc[2];
+
+               RNA_float_get_array(&itemptr, "loc", loc);
+               UI_view2d_region_to_view(&ar->v2d, (short)loc[0], (short)loc[1],
+                                        &mcoords[i][0], &mcoords[i][1]);
+               i++;
+               if (i >= 256) break;
+       }
+       RNA_END;
+
+       if (i > 1) {
+               bNodeLink *link;
+               float insertPoint[2];
+
+               ED_preview_kill_jobs(C);
+
+               for (link = snode->edittree->links.first; link; link = link->next) {
+                       if (add_reroute_intersect_check(link, mcoords, i, insertPoint)) {
+                               bNodeTemplate ntemp;
+                               bNode *rerouteNode;
+                               
+                               node_deselect_all(snode);
+                               
+                               ntemp.type = NODE_REROUTE;
+                               rerouteNode = nodeAddNode(snode->edittree, &ntemp);
+                               if (gnode) {
+                                       nodeFromView(gnode, insertPoint[0], insertPoint[1], &rerouteNode->locx, &rerouteNode->locy);
+                               }
+                               else {
+                                       rerouteNode->locx = insertPoint[0];
+                                       rerouteNode->locy = insertPoint[1];
+                               }
+                               
+                               nodeAddLink(snode->edittree, link->fromnode, link->fromsock, rerouteNode, rerouteNode->inputs.first);
+                               link->fromnode = rerouteNode;
+                               link->fromsock = rerouteNode->outputs.first;
+                               
+                               break; // add one reroute at the time.
+                       }
+               }
+
+               ntreeUpdateTree(snode->edittree);
+               snode_notify(C, snode);
+               snode_dag_update(C, snode);
+
+               return OPERATOR_FINISHED;
+       }
+
+       return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
+}
+
+void NODE_OT_add_reroute(wmOperatorType *ot)
+{
+       PropertyRNA *prop;
+
+       ot->name = "Add reroute";
+       ot->idname = "NODE_OT_add_reroute";
+
+       ot->invoke = WM_gesture_lines_invoke;
+       ot->modal = WM_gesture_lines_modal;
+       ot->exec = add_reroute_exec;
+       ot->cancel = WM_gesture_lines_cancel;
+
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       prop = RNA_def_property(ot->srna, "path", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_runtime(prop, &RNA_OperatorMousePath);
+       /* internal */
+       RNA_def_int(ot->srna, "cursor", BC_CROSSCURSOR, 0, INT_MAX, "Cursor", "", 0, INT_MAX);
+}
+
+
+/* ********************** Cut Link operator ***************** */
 static int cut_links_intersect(bNodeLink *link, float mcoords[][2], int tot)
 {
-       float coord_array[LINK_RESOL+1][2];
+       float coord_array[LINK_RESOL + 1][2];
        int i, b;
-       
-       if(node_link_bezier_points(NULL, NULL, link, coord_array, LINK_RESOL)) {
 
-               for(i=0; i<tot-1; i++)
-                       for(b=0; b<LINK_RESOL; b++)
-                               if(isect_line_line_v2(mcoords[i], mcoords[i+1], coord_array[b], coord_array[b+1]) > 0)
+       if (node_link_bezier_points(NULL, NULL, link, coord_array, LINK_RESOL)) {
+
+               for (i = 0; i < tot - 1; i++)
+                       for (b = 0; b < LINK_RESOL; b++)
+                               if (isect_line_line_v2(mcoords[i], mcoords[i + 1], coord_array[b], coord_array[b + 1]) > 0)
                                        return 1;
        }
        return 0;
@@ -2571,31 +3241,32 @@ static int cut_links_intersect(bNodeLink *link, float mcoords[][2], int tot)
 
 static int cut_links_exec(bContext *C, wmOperator *op)
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
-       ARegion *ar= CTX_wm_region(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
        float mcoords[256][2];
-       int i= 0;
+       int i = 0;
        
-       RNA_BEGIN(op->ptr, itemptr, "path") {
+       RNA_BEGIN(op->ptr, itemptr, "path")
+       {
                float loc[2];
                
                RNA_float_get_array(&itemptr, "loc", loc);
-               UI_view2d_region_to_view(&ar->v2d, (short)loc[0], (short)loc[1], 
-                                                                &mcoords[i][0], &mcoords[i][1]);
+               UI_view2d_region_to_view(&ar->v2d, (int)loc[0], (int)loc[1],
+                                        &mcoords[i][0], &mcoords[i][1]);
                i++;
-               if(i>= 256) break;
+               if (i >= 256) break;
        }
        RNA_END;
        
-       if(i>1) {
+       if (i > 1) {
                bNodeLink *link, *next;
 
                ED_preview_kill_jobs(C);
                
-               for(link= snode->edittree->links.first; link; link= next) {
-                       next= link->next;
+               for (link = snode->edittree->links.first; link; link = next) {
+                       next = link->next;
                        
-                       if(cut_links_intersect(link, mcoords, i)) {
+                       if (cut_links_intersect(link, mcoords, i)) {
                                snode_update(snode, link->tonode);
                                nodeRemLink(snode->edittree, link);
                        }
@@ -2608,94 +3279,133 @@ static int cut_links_exec(bContext *C, wmOperator *op)
                return OPERATOR_FINISHED;
        }
        
-       return OPERATOR_CANCELLED|OPERATOR_PASS_THROUGH;
+       return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
 }
 
 void NODE_OT_links_cut(wmOperatorType *ot)
 {
        PropertyRNA *prop;
        
-       ot->name= "Cut links";
-       ot->idname= "NODE_OT_links_cut";
+       ot->name = "Cut links";
+       ot->idname = "NODE_OT_links_cut";
+       ot->description = "Use the mouse to cut (remove) some links";
        
-       ot->invoke= WM_gesture_lines_invoke;
-       ot->modal= WM_gesture_lines_modal;
-       ot->exec= cut_links_exec;
-       ot->cancel= WM_gesture_lines_cancel;
+       ot->invoke = WM_gesture_lines_invoke;
+       ot->modal = WM_gesture_lines_modal;
+       ot->exec = cut_links_exec;
+       ot->cancel = WM_gesture_lines_cancel;
        
-       ot->poll= ED_operator_node_active;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       prop= RNA_def_property(ot->srna, "path", PROP_COLLECTION, PROP_NONE);
+       prop = RNA_def_property(ot->srna, "path", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_struct_runtime(prop, &RNA_OperatorMousePath);
        /* internal */
        RNA_def_int(ot->srna, "cursor", BC_KNIFECURSOR, 0, INT_MAX, "Cursor", "", 0, INT_MAX);
 }
 
-/* *********************  automatic node insert on dragging ******************* */
+/* ********************** Detach links operator ***************** */
 
-/* assumes sockets in list */
-static bNodeSocket *socket_best_match(ListBase *sockets, int type)
+static int detach_links_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       bNodeSocket *sock;
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *node;
        
-       /* first, match type */
-       for(sock= sockets->first; sock; sock= sock->next)
-               if(!nodeSocketIsHidden(sock))
-                       if(type == sock->type)
-                               return sock;
+       ED_preview_kill_jobs(C);
        
-       /* then just use first unhidden socket */
-       for(sock= sockets->first; sock; sock= sock->next)
-               if(!nodeSocketIsHidden(sock))
-                       return sock;
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
+                       nodeInternalRelink(ntree, node);
+               }
+       }
+       
+       ntreeUpdateTree(ntree);
+       
+       snode_notify(C, snode);
+       snode_dag_update(C, snode);
 
-       /* OK, let's unhide proper one */
-       for(sock= sockets->first; sock; sock= sock->next) {
-               if(type == sock->type) {
-                       sock->flag &= ~(SOCK_HIDDEN|SOCK_AUTO_HIDDEN);
-                       return sock;
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_links_detach(wmOperatorType *ot)
+{
+       ot->name = "Detach Links";
+       ot->idname = "NODE_OT_links_detach";
+       ot->description = "Remove all links to selected nodes, and try to connect neighbor nodes together";
+       
+       ot->exec = detach_links_exec;
+       ot->poll = ED_operator_node_active;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* *********************  automatic node insert on dragging ******************* */
+
+/* assumes sockets in list */
+static bNodeSocket *socket_best_match(ListBase *sockets)
+{
+       bNodeSocket *sock;
+       int type, maxtype = 0;
+       
+       /* find type range */
+       for (sock = sockets->first; sock; sock = sock->next)
+               maxtype = MAX2(sock->type, maxtype);
+       
+       /* try all types, starting from 'highest' (i.e. colors, vectors, values) */
+       for (type = maxtype; type >= 0; --type) {
+               for (sock = sockets->first; sock; sock = sock->next) {
+                       if (!nodeSocketIsHidden(sock) && type == sock->type) {
+                               return sock;
+                       }
                }
        }
        
-       /* just the first */
-       sock= sockets->first;
-       sock->flag &= ~(SOCK_HIDDEN|SOCK_AUTO_HIDDEN);
+       /* no visible sockets, unhide first of highest type */
+       for (type = maxtype; type >= 0; --type) {
+               for (sock = sockets->first; sock; sock = sock->next) {
+                       if (type == sock->type) {
+                               sock->flag &= ~SOCK_HIDDEN;
+                               return sock;
+                       }
+               }
+       }
        
-       return sockets->first;
+       return NULL;
 }
 
 /* prevent duplicate testing code below */
 static SpaceNode *ed_node_link_conditions(ScrArea *sa, bNode **select)
 {
-       SpaceNode *snode= sa?sa->spacedata.first:NULL;
+       SpaceNode *snode = sa ? sa->spacedata.first : NULL;
        bNode *node;
        bNodeLink *link;
        
        /* no unlucky accidents */
-       if(sa==NULL || sa->spacetype!=SPACE_NODE) return NULL;
+       if (sa == NULL || sa->spacetype != SPACE_NODE) return NULL;
        
-       *select= NULL;
+       *select = NULL;
        
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
-                       if(*select)
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
+                       if (*select)
                                break;
                        else
-                               *select= node;
+                               *select = node;
                }
        }
        /* only one selected */
-       if(node || *select==NULL) return NULL;
+       if (node || *select == NULL) return NULL;
        
        /* correct node */
-       if((*select)->inputs.first==NULL || (*select)->outputs.first==NULL) return NULL;
+       if ((*select)->inputs.first == NULL || (*select)->outputs.first == NULL) return NULL;
        
        /* test node for links */
-       for(link= snode->edittree->links.first; link; link=link->next) {
-               if(link->tonode == *select || link->fromnode == *select)
+       for (link = snode->edittree->links.first; link; link = link->next) {
+               if (link->tonode == *select || link->fromnode == *select)
                        return NULL;
        }
        
@@ -2706,27 +3416,27 @@ static SpaceNode *ed_node_link_conditions(ScrArea *sa, bNode **select)
 void ED_node_link_insert(ScrArea *sa)
 {
        bNode *node, *select;
-       SpaceNode *snode= ed_node_link_conditions(sa, &select);
+       SpaceNode *snode = ed_node_link_conditions(sa, &select);
        bNodeLink *link;
        bNodeSocket *sockto;
        
-       if(snode==NULL) return;
+       if (snode == NULL) return;
        
        /* get the link */
-       for(link= snode->edittree->links.first; link; link=link->next)
-               if(link->flag & NODE_LINKFLAG_HILITE)
+       for (link = snode->edittree->links.first; link; link = link->next)
+               if (link->flag & NODE_LINKFLAG_HILITE)
                        break;
        
-       if(link) {
-               node= link->tonode;
-               sockto= link->tosock;
+       if (link) {
+               node = link->tonode;
+               sockto = link->tosock;
                
-               link->tonode= select;
-               link->tosock= socket_best_match(&select->inputs, link->fromsock->type);
+               link->tonode = select;
+               link->tosock = socket_best_match(&select->inputs);
                link->flag &= ~NODE_LINKFLAG_HILITE;
                
-               nodeAddLink(snode->edittree, select, socket_best_match(&select->outputs, sockto->type), node, sockto);
-               ntreeUpdateTree(snode->edittree);       /* needed for pointers */
+               nodeAddLink(snode->edittree, select, socket_best_match(&select->outputs), node, sockto);
+               ntreeUpdateTree(snode->edittree);   /* needed for pointers */
                snode_update(snode, select);
                ED_node_changed_update(snode->id, select);
        }
@@ -2737,44 +3447,44 @@ void ED_node_link_insert(ScrArea *sa)
 void ED_node_link_intersect_test(ScrArea *sa, int test)
 {
        bNode *select;
-       SpaceNode *snode= ed_node_link_conditions(sa, &select);
-       bNodeLink *link, *selink=NULL;
+       SpaceNode *snode = ed_node_link_conditions(sa, &select);
+       bNodeLink *link, *selink = NULL;
        float mcoords[6][2];
        
-       if(snode==NULL) return;
+       if (snode == NULL) return;
        
        /* clear flags */
-       for(link= snode->edittree->links.first; link; link=link->next)
+       for (link = snode->edittree->links.first; link; link = link->next)
                link->flag &= ~NODE_LINKFLAG_HILITE;
        
-       if(test==0) return;
+       if (test == 0) return;
        
        /* okay, there's 1 node, without links, now intersect */
-       mcoords[0][0]= select->totr.xmin;
-       mcoords[0][1]= select->totr.ymin;
-       mcoords[1][0]= select->totr.xmax;
-       mcoords[1][1]= select->totr.ymin;
-       mcoords[2][0]= select->totr.xmax;
-       mcoords[2][1]= select->totr.ymax;
-       mcoords[3][0]= select->totr.xmin;
-       mcoords[3][1]= select->totr.ymax;
-       mcoords[4][0]= select->totr.xmin;
-       mcoords[4][1]= select->totr.ymin;
-       mcoords[5][0]= select->totr.xmax;
-       mcoords[5][1]= select->totr.ymax;
+       mcoords[0][0] = select->totr.xmin;
+       mcoords[0][1] = select->totr.ymin;
+       mcoords[1][0] = select->totr.xmax;
+       mcoords[1][1] = select->totr.ymin;
+       mcoords[2][0] = select->totr.xmax;
+       mcoords[2][1] = select->totr.ymax;
+       mcoords[3][0] = select->totr.xmin;
+       mcoords[3][1] = select->totr.ymax;
+       mcoords[4][0] = select->totr.xmin;
+       mcoords[4][1] = select->totr.ymin;
+       mcoords[5][0] = select->totr.xmax;
+       mcoords[5][1] = select->totr.ymax;
        
        /* we only tag a single link for intersect now */
        /* idea; use header dist when more? */
-       for(link= snode->edittree->links.first; link; link=link->next) {
+       for (link = snode->edittree->links.first; link; link = link->next) {
                
-               if(cut_links_intersect(link, mcoords, 5)) { /* intersect code wants edges */
-                       if(selink) 
+               if (cut_links_intersect(link, mcoords, 5)) { /* intersect code wants edges */
+                       if (selink)
                                break;
-                       selink= link;
+                       selink = link;
                }
        }
                
-       if(link==NULL && selink)
+       if (link == NULL && selink)
                selink->flag |= NODE_LINKFLAG_HILITE;
 }
 
@@ -2786,21 +3496,21 @@ void ED_node_link_intersect_test(ScrArea *sa, int test)
 /* goes over all scenes, reads render layers */
 static int node_read_renderlayers_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Main *bmain= CTX_data_main(C);
-       SpaceNode *snode= CTX_wm_space_node(C);
-       Scene *curscene= CTX_data_scene(C), *scene;
+       Main *bmain = CTX_data_main(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       Scene *curscene = CTX_data_scene(C), *scene;
        bNode *node;
 
        ED_preview_kill_jobs(C);
 
        /* first tag scenes unread */
-       for(scene= bmain->scene.first; scene; scene= scene->id.next) 
+       for (scene = bmain->scene.first; scene; scene = scene->id.next)
                scene->id.flag |= LIB_DOIT;
 
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->type==CMP_NODE_R_LAYERS) {
-                       ID *id= node->id;
-                       if(id->flag & LIB_DOIT) {
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->type == CMP_NODE_R_LAYERS) {
+                       ID *id = node->id;
+                       if (id->flag & LIB_DOIT) {
                                RE_ReadRenderResult(curscene, (Scene *)id);
                                ntreeCompositTagRender((Scene *)id);
                                id->flag &= ~LIB_DOIT;
@@ -2817,31 +3527,32 @@ static int node_read_renderlayers_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_read_renderlayers(wmOperatorType *ot)
 {
        
-       ot->name= "Read Render Layers";
-       ot->idname= "NODE_OT_read_renderlayers";
+       ot->name = "Read Render Layers";
+       ot->idname = "NODE_OT_read_renderlayers";
+       ot->description = "Read all render layers of all used scenes";
        
-       ot->exec= node_read_renderlayers_exec;
+       ot->exec = node_read_renderlayers_exec;
        
-       ot->poll= composite_node_active;
+       ot->poll = composite_node_active;
        
        /* flags */
-       ot->flag= 0;
+       ot->flag = 0;
 }
 
 static int node_read_fullsamplelayers_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Main *bmain= CTX_data_main(C);
-       SpaceNode *snode= CTX_wm_space_node(C);
-       Scene *curscene= CTX_data_scene(C);
-       Render *re= RE_NewRender(curscene->id.name);
+       Main *bmain = CTX_data_main(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       Scene *curscene = CTX_data_scene(C);
+       Render *re = RE_NewRender(curscene->id.name);
 
        WM_cursor_wait(1);
        RE_MergeFullSample(re, bmain, curscene, snode->nodetree);
        WM_cursor_wait(0);
 
        /* note we are careful to send the right notifier, as otherwise the
-          compositor would reexecute and overwrite the full sample result */
-       WM_event_add_notifier(C, NC_SCENE|ND_COMPO_RESULT, NULL);
+        * compositor would reexecute and overwrite the full sample result */
+       WM_event_add_notifier(C, NC_SCENE | ND_COMPO_RESULT, NULL);
 
        return OPERATOR_FINISHED;
 }
@@ -2850,36 +3561,37 @@ static int node_read_fullsamplelayers_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_read_fullsamplelayers(wmOperatorType *ot)
 {
        
-       ot->name= "Read Full Sample Layers";
-       ot->idname= "NODE_OT_read_fullsamplelayers";
+       ot->name = "Read Full Sample Layers";
+       ot->idname = "NODE_OT_read_fullsamplelayers";
+       ot->description = "Read all render layers of current scene, in full sample";
        
-       ot->exec= node_read_fullsamplelayers_exec;
+       ot->exec = node_read_fullsamplelayers_exec;
        
-       ot->poll= composite_node_active;
+       ot->poll = composite_node_active;
        
        /* flags */
-       ot->flag= 0;
+       ot->flag = 0;
 }
 
 int node_render_changed_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Scene *sce= CTX_data_scene(C);
+       Scene *sce = CTX_data_scene(C);
        bNode *node;
        
-       for(node= sce->nodetree->nodes.first; node; node= node->next) {
-               if(node->id==(ID *)sce && node->need_exec) {
+       for (node = sce->nodetree->nodes.first; node; node = node->next) {
+               if (node->id == (ID *)sce && node->need_exec) {
                        break;
                }
        }
-       if(node) {
-               SceneRenderLayer *srl= BLI_findlink(&sce->r.layers, node->custom1);
+       if (node) {
+               SceneRenderLayer *srl = BLI_findlink(&sce->r.layers, node->custom1);
                
-               if(srl) {
+               if (srl) {
                        PointerRNA op_ptr;
                        
                        WM_operator_properties_create(&op_ptr, "RENDER_OT_render");
                        RNA_string_set(&op_ptr, "layer", srl->name);
-                       RNA_string_set(&op_ptr, "scene", sce->id.name+2);
+                       RNA_string_set(&op_ptr, "scene", sce->id.name + 2);
                        
                        /* to keep keypositions */
                        sce->r.scemode |= R_NO_FRAME_UPDATE;
@@ -2898,62 +3610,320 @@ int node_render_changed_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_render_changed(wmOperatorType *ot)
 {
        
-       ot->name= "Render Changed Layer";
-       ot->idname= "NODE_OT_render_changed";
+       ot->name = "Render Changed Layer";
+       ot->idname = "NODE_OT_render_changed";
+       ot->description = "Render current scene, when input node's layer has been changed";
        
-       ot->exec= node_render_changed_exec;
+       ot->exec = node_render_changed_exec;
        
-       ot->poll= composite_node_active;
+       ot->poll = composite_node_active;
        
        /* flags */
-       ot->flag= 0;
+       ot->flag = 0;
 }
 
 
 /* ****************** Make Group operator ******************* */
 
+static int node_group_make_test(bNodeTree *ntree, bNode *gnode)
+{
+       bNode *node;
+       bNodeLink *link;
+       int totnode = 0;
+       
+       /* is there something to group? also do some clearing */
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node == gnode)
+                       continue;
+               
+               if (node->flag & NODE_SELECT) {
+                       /* no groups in groups */
+                       if (node->type == NODE_GROUP)
+                               return 0;
+                       totnode++;
+               }
+               
+               node->done = 0;
+       }
+       if (totnode == 0) return 0;
+       
+       /* check if all connections are OK, no unselected node has both
+        * inputs and outputs to a selection */
+       for (link = ntree->links.first; link; link = link->next) {
+               if (link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT && link->fromnode != gnode)
+                       link->tonode->done |= 1;
+               if (link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT && link->tonode != gnode)
+                       link->fromnode->done |= 2;
+       }
+       
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node == gnode)
+                       continue;
+               if ((node->flag & NODE_SELECT) == 0)
+                       if (node->done == 3)
+                               break;
+       }
+       if (node) 
+               return 0;
+       
+       return 1;
+}
+
+static void node_get_selected_minmax(bNodeTree *ntree, bNode *gnode, float *min, float *max)
+{
+       bNode *node;
+       INIT_MINMAX2(min, max);
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node == gnode)
+                       continue;
+               if (node->flag & NODE_SELECT) {
+                       DO_MINMAX2((&node->locx), min, max);
+               }
+       }
+}
+
+static int node_group_make_insert_selected(bNodeTree *ntree, bNode *gnode)
+{
+       bNodeTree *ngroup = (bNodeTree *)gnode->id;
+       bNodeLink *link, *linkn;
+       bNode *node, *nextn;
+       bNodeSocket *gsock;
+       ListBase anim_basepaths = {NULL, NULL};
+       float min[2], max[2];
+       
+       /* deselect all nodes in the target tree */
+       for (node = ngroup->nodes.first; node; node = node->next)
+               node_deselect(node);
+       
+       node_get_selected_minmax(ntree, gnode, min, max);
+       
+       /* move nodes over */
+       for (node = ntree->nodes.first; node; node = nextn) {
+               nextn = node->next;
+               if (node == gnode)
+                       continue;
+               if (node->flag & NODE_SELECT) {
+                       /* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
+                        * if the old nodetree has animation data which potentially covers this node
+                        */
+                       if (ntree->adt) {
+                               PointerRNA ptr;
+                               char *path;
+                               
+                               RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
+                               path = RNA_path_from_ID_to_struct(&ptr);
+                               
+                               if (path)
+                                       BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
+                       }
+                       
+                       /* ensure valid parent pointers, detach if parent stays outside the group */
+                       if (node->parent && !(node->parent->flag & NODE_SELECT))
+                               nodeDetachNode(node);
+                       
+                       /* change node-collection membership */
+                       BLI_remlink(&ntree->nodes, node);
+                       BLI_addtail(&ngroup->nodes, node);
+                       
+                       /* ensure unique node name in the ngroup */
+                       nodeUniqueName(ngroup, node);
+                       
+                       node->locx -= 0.5f * (min[0] + max[0]);
+                       node->locy -= 0.5f * (min[1] + max[1]);
+               }
+       }
+       
+       /* move animation data over */
+       if (ntree->adt) {
+               LinkData *ld, *ldn = NULL;
+               
+               BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
+               
+               /* paths + their wrappers need to be freed */
+               for (ld = anim_basepaths.first; ld; ld = ldn) {
+                       ldn = ld->next;
+                       
+                       MEM_freeN(ld->data);
+                       BLI_freelinkN(&anim_basepaths, ld);
+               }
+       }
+       
+       /* node groups don't use internal cached data */
+       ntreeFreeCache(ngroup);
+       
+       /* relink external sockets */
+       for (link = ntree->links.first; link; link = linkn) {
+               int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT) && link->fromnode != gnode);
+               int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT) && link->tonode != gnode);
+               linkn = link->next;
+               
+               if (gnode && ((fromselect && link->tonode == gnode) || (toselect && link->fromnode == gnode))) {
+                       /* remove all links to/from the gnode.
+                        * this can remove link information, but there's no general way to preserve it.
+                        */
+                       nodeRemLink(ntree, link);
+               }
+               else if (fromselect && toselect) {
+                       BLI_remlink(&ntree->links, link);
+                       BLI_addtail(&ngroup->links, link);
+               }
+               else if (toselect) {
+                       gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
+                       link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
+                       link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
+                       link->tonode = gnode;
+               }
+               else if (fromselect) {
+                       /* search for existing group node socket */
+                       for (gsock = ngroup->outputs.first; gsock; gsock = gsock->next)
+                               if (gsock->link && gsock->link->fromsock == link->fromsock)
+                                       break;
+                       if (!gsock) {
+                               gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
+                               gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
+                               link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
+                       }
+                       else
+                               link->fromsock = node_group_find_output(gnode, gsock);
+                       link->fromnode = gnode;
+               }
+       }
+
+       /* update of the group tree */
+       ngroup->update |= NTREE_UPDATE;
+       /* update of the tree containing the group instance node */
+       ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
+
+       return 1;
+}
+
+static bNode *node_group_make_from_selected(bNodeTree *ntree)
+{
+       bNode *gnode;
+       bNodeTree *ngroup;
+       float min[2], max[2];
+       bNodeTemplate ntemp;
+       
+       node_get_selected_minmax(ntree, NULL, min, max);
+       
+       /* new nodetree */
+       ngroup = ntreeAddTree("NodeGroup", ntree->type, NODE_GROUP);
+       
+       /* make group node */
+       ntemp.type = NODE_GROUP;
+       ntemp.ngroup = ngroup;
+       gnode = nodeAddNode(ntree, &ntemp);
+       gnode->locx = 0.5f * (min[0] + max[0]);
+       gnode->locy = 0.5f * (min[1] + max[1]);
+       
+       node_group_make_insert_selected(ntree, gnode);
+
+       /* update of the tree containing the group instance node */
+       ntree->update |= NTREE_UPDATE_NODES;
+
+       return gnode;
+}
+
+typedef enum eNodeGroupMakeType {
+       NODE_GM_NEW,
+       NODE_GM_INSERT
+} eNodeGroupMakeType;
+
+/* Operator Property */
+EnumPropertyItem node_group_make_types[] = {
+       {NODE_GM_NEW, "NEW", 0, "New", "Create a new node group from selected nodes"},
+       {NODE_GM_INSERT, "INSERT", 0, "Insert", "Insert into active node group"},
+       {0, NULL, 0, NULL, NULL}
+};
+
 static int node_group_make_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
        bNode *gnode;
+       int type = RNA_enum_get(op->ptr, "type");
        
-       if(snode->edittree!=snode->nodetree) {
+       if (snode->edittree != snode->nodetree) {
                BKE_report(op->reports, RPT_WARNING, "Can not add a new Group in a Group");
                return OPERATOR_CANCELLED;
        }
        
        /* for time being... is too complex to handle */
-       if(snode->treetype==NTREE_COMPOSIT) {
-               for(gnode=snode->nodetree->nodes.first; gnode; gnode= gnode->next) {
-                       if(gnode->flag & SELECT)
-                               if(gnode->type==CMP_NODE_R_LAYERS)
+       if (snode->treetype == NTREE_COMPOSIT) {
+               for (gnode = snode->nodetree->nodes.first; gnode; gnode = gnode->next) {
+                       if (gnode->flag & SELECT)
+                               if (gnode->type == CMP_NODE_R_LAYERS)
                                        break;
                }
                
-               if(gnode) {
+               if (gnode) {
                        BKE_report(op->reports, RPT_WARNING, "Can not add RenderLayer in a Group");
                        return OPERATOR_CANCELLED;
                }
        }
-
-       ED_preview_kill_jobs(C);
        
-       gnode= node_group_make_from_selected(snode->nodetree);
-       if(gnode==NULL) {
-               BKE_report(op->reports, RPT_WARNING, "Can not make Group");
-               return OPERATOR_CANCELLED;
+       ED_preview_kill_jobs(C);
+
+       switch (type) {
+               case NODE_GM_NEW:
+                       if (node_group_make_test(snode->nodetree, NULL)) {
+                               gnode = node_group_make_from_selected(snode->nodetree);
+                       }
+                       else {
+                               BKE_report(op->reports, RPT_WARNING, "Can not make Group");
+                               return OPERATOR_CANCELLED;
+                       }
+                       break;
+               case NODE_GM_INSERT:
+                       gnode = nodeGetActive(snode->nodetree);
+                       if (!gnode || gnode->type != NODE_GROUP) {
+                               BKE_report(op->reports, RPT_WARNING, "No active Group node");
+                               return OPERATOR_CANCELLED;
+                       }
+                       if (node_group_make_test(snode->nodetree, gnode)) {
+                               node_group_make_insert_selected(snode->nodetree, gnode);
+                       }
+                       else {
+                               BKE_report(op->reports, RPT_WARNING, "Can not insert into Group");
+                               return OPERATOR_CANCELLED;
+                       }
+                       break;
        }
-       else {
+
+       if (gnode) {
                nodeSetActive(snode->nodetree, gnode);
-               ntreeUpdateTree(snode->nodetree);
+               snode_make_group_editable(snode, gnode);
        }
        
+       if (gnode)
+               ntreeUpdateTree((bNodeTree *)gnode->id);
+       ntreeUpdateTree(snode->nodetree);
+
        snode_notify(C, snode);
        snode_dag_update(C, snode);
        
        return OPERATOR_FINISHED;
 }
 
+static int node_group_make_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *UNUSED(event))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNode *act = nodeGetActive(snode->edittree);
+       uiPopupMenu *pup = uiPupMenuBegin(C, "Make Group", ICON_NONE);
+       uiLayout *layout = uiPupMenuLayout(pup);
+       
+       uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
+       uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_NEW);
+       
+       /* if active node is a group, add insert option */
+       if (act && act->type == NODE_GROUP) {
+               uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_INSERT);
+       }
+       
+       uiPupMenuEnd(C, pup);
+       
+       return OPERATOR_CANCELLED;
+}
+
 void NODE_OT_group_make(wmOperatorType *ot)
 {
        /* identifiers */
@@ -2962,11 +3932,14 @@ void NODE_OT_group_make(wmOperatorType *ot)
        ot->idname = "NODE_OT_group_make";
        
        /* api callbacks */
+       ot->invoke = node_group_make_invoke;
        ot->exec = node_group_make_exec;
        ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       
+       RNA_def_enum(ot->srna, "type", node_group_make_types, NODE_GM_NEW, "Type", "");
 }
 
 /* ****************** Hide operator *********************** */
@@ -2974,88 +3947,78 @@ void NODE_OT_group_make(wmOperatorType *ot)
 static void node_flag_toggle_exec(SpaceNode *snode, int toggle_flag)
 {
        bNode *node;
-       int tot_eq= 0, tot_neq= 0;
+       int tot_eq = 0, tot_neq = 0;
 
        /* Toggles the flag on all selected nodes.
         * If the flag is set on all nodes it is unset.
         * If the flag is not set on all nodes, it is set.
         */
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
                        
-                       if(toggle_flag== NODE_PREVIEW && (node->typeinfo->flag & NODE_PREVIEW)==0)
+                       if (toggle_flag == NODE_PREVIEW && (node->typeinfo->flag & NODE_PREVIEW) == 0)
                                continue;
-                       if(toggle_flag== NODE_OPTIONS && (node->typeinfo->flag & NODE_OPTIONS)==0)
+                       if (toggle_flag == NODE_OPTIONS && (node->typeinfo->flag & NODE_OPTIONS) == 0)
                                continue;
                        
-                       if(node->flag & toggle_flag)
+                       if (node->flag & toggle_flag)
                                tot_eq++;
                        else
                                tot_neq++;
                }
        }
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
                        
-                       if(toggle_flag== NODE_PREVIEW && (node->typeinfo->flag & NODE_PREVIEW)==0)
+                       if (toggle_flag == NODE_PREVIEW && (node->typeinfo->flag & NODE_PREVIEW) == 0)
                                continue;
-                       if(toggle_flag== NODE_OPTIONS && (node->typeinfo->flag & NODE_OPTIONS)==0)
+                       if (toggle_flag == NODE_OPTIONS && (node->typeinfo->flag & NODE_OPTIONS) == 0)
                                continue;
                        
-                       if( (tot_eq && tot_neq) || tot_eq==0) {
+                       if ( (tot_eq && tot_neq) || tot_eq == 0)
                                node->flag |= toggle_flag;
-                               
-                               /* hide/unhide node also toggles unlinked socket display */
-                               if (toggle_flag== NODE_HIDDEN)
-                                       node_set_hidden_sockets(snode, node, SOCK_AUTO_HIDDEN, 1);
-                       }
-                       else {
+                       else
                                node->flag &= ~toggle_flag;
-                               
-                               /* hide/unhide node also toggles unlinked socket display */
-                               if (toggle_flag== NODE_HIDDEN)
-                                       node_set_hidden_sockets(snode, node, SOCK_AUTO_HIDDEN, 0);
-                       }
                }
        }
 }
 
 static int node_hide_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        
        /* sanity checking (poll callback checks this already) */
-       if((snode == NULL) || (snode->edittree == NULL))
+       if ((snode == NULL) || (snode->edittree == NULL))
                return OPERATOR_CANCELLED;
        
        node_flag_toggle_exec(snode, NODE_HIDDEN);
-       
-       snode_notify(C, snode);
-       
+
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+
        return OPERATOR_FINISHED;
 }
 
 void NODE_OT_hide_toggle(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Hide";
-       ot->description= "Toggle hiding of selected nodes";
-       ot->idname= "NODE_OT_hide_toggle";
+       ot->name = "Hide";
+       ot->description = "Toggle hiding of selected nodes";
+       ot->idname = "NODE_OT_hide_toggle";
        
        /* callbacks */
-       ot->exec= node_hide_toggle_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_hide_toggle_exec;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 static int node_preview_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
 
        /* sanity checking (poll callback checks this already) */
-       if((snode == NULL) || (snode->edittree == NULL))
+       if ((snode == NULL) || (snode->edittree == NULL))
                return OPERATOR_CANCELLED;
 
        ED_preview_kill_jobs(C);
@@ -3070,29 +4033,29 @@ static int node_preview_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_preview_toggle(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Toggle Node Preview";
-       ot->description= "Toggle preview display for selected nodes";
-       ot->idname= "NODE_OT_preview_toggle";
+       ot->name = "Toggle Node Preview";
+       ot->description = "Toggle preview display for selected nodes";
+       ot->idname = "NODE_OT_preview_toggle";
 
        /* callbacks */
-       ot->exec= node_preview_toggle_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_preview_toggle_exec;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 static int node_options_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
 
        /* sanity checking (poll callback checks this already) */
-       if((snode == NULL) || (snode->edittree == NULL))
+       if ((snode == NULL) || (snode->edittree == NULL))
                return OPERATOR_CANCELLED;
 
        node_flag_toggle_exec(snode, NODE_OPTIONS);
 
-       snode_notify(C, snode);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
 
        return OPERATOR_FINISHED;
 }
@@ -3100,50 +4063,50 @@ static int node_options_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_options_toggle(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Toggle Node Options";
-       ot->description= "Toggle option buttons display for selected nodes";
-       ot->idname= "NODE_OT_options_toggle";
+       ot->name = "Toggle Node Options";
+       ot->description = "Toggle option buttons display for selected nodes";
+       ot->idname = "NODE_OT_options_toggle";
 
        /* callbacks */
-       ot->exec= node_options_toggle_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_options_toggle_exec;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 static int node_socket_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node;
        int hidden;
 
        /* sanity checking (poll callback checks this already) */
-       if((snode == NULL) || (snode->edittree == NULL))
+       if ((snode == NULL) || (snode->edittree == NULL))
                return OPERATOR_CANCELLED;
 
        ED_preview_kill_jobs(C);
 
        /* Toggle for all selected nodes */
        hidden = 0;
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
-                       if(node_has_hidden_sockets(node, SOCK_HIDDEN)) {
-                               hidden= 1;
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
+                       if (node_has_hidden_sockets(node)) {
+                               hidden = 1;
                                break;
                        }
                }
        }
        
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
-               if(node->flag & SELECT) {
-                       node_set_hidden_sockets(snode, node, SOCK_HIDDEN, !hidden);
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & SELECT) {
+                       node_set_hidden_sockets(snode, node, !hidden);
                }
        }
 
        ntreeUpdateTree(snode->edittree);
 
-       snode_notify(C, snode);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
 
        return OPERATOR_FINISHED;
 }
@@ -3151,34 +4114,32 @@ static int node_socket_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_hide_socket_toggle(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Toggle Hidden Node Sockets";
-       ot->description= "Toggle unused node socket display";
-       ot->idname= "NODE_OT_hide_socket_toggle";
+       ot->name = "Toggle Hidden Node Sockets";
+       ot->description = "Toggle unused node socket display";
+       ot->idname = "NODE_OT_hide_socket_toggle";
 
        /* callbacks */
-       ot->exec= node_socket_toggle_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_socket_toggle_exec;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ****************** Mute operator *********************** */
 
 static int node_mute_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node;
 
        ED_preview_kill_jobs(C);
 
-       for(node= snode->edittree->nodes.first; node; node= node->next) {
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
                /* Only allow muting of nodes having a mute func! */
-               if((node->flag & SELECT) && node->typeinfo->mutefunc) {
-                       /* Be able to mute in-/output nodes as well.  - DingTo
-                       if(node->inputs.first && node->outputs.first) { */
-                               node->flag ^= NODE_MUTED;
-                               snode_update(snode, node);
+               if ((node->flag & SELECT) && node->typeinfo->internal_connect) {
+                       node->flag ^= NODE_MUTED;
+                       snode_update(snode, node);
                }
        }
        
@@ -3191,32 +4152,32 @@ static int node_mute_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_mute_toggle(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Toggle Node Mute";
-       ot->description= "Toggle muting of the nodes";
-       ot->idname= "NODE_OT_mute_toggle";
+       ot->name = "Toggle Node Mute";
+       ot->description = "Toggle muting of the nodes";
+       ot->idname = "NODE_OT_mute_toggle";
        
        /* callbacks */
-       ot->exec= node_mute_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_mute_exec;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ****************** Delete operator ******************* */
 
 static int node_delete_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node, *next;
        
        ED_preview_kill_jobs(C);
 
-       for(node= snode->edittree->nodes.first; node; node= next) {
-               next= node->next;
-               if(node->flag & SELECT) {
+       for (node = snode->edittree->nodes.first; node; node = next) {
+               next = node->next;
+               if (node->flag & SELECT) {
                        /* check id user here, nodeFreeNode is called for free dbase too */
-                       if(node->id)
+                       if (node->id)
                                node->id->us--;
                        nodeFreeNode(snode->edittree, node);
                }
@@ -3233,142 +4194,35 @@ static int node_delete_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_delete(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Delete";
+       ot->name = "Delete";
        ot->description = "Delete selected nodes";
-       ot->idname= "NODE_OT_delete";
+       ot->idname = "NODE_OT_delete";
        
        /* api callbacks */
-       ot->exec= node_delete_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_delete_exec;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ****************** Delete with reconnect ******************* */
-static int is_connected_to_input_socket(bNode* node, bNodeLink* link)
-{
-       bNodeSocket *sock;
-       if (link->tonode == node) {
-               for(sock= node->inputs.first; sock; sock= sock->next) {
-                       if (link->tosock == sock) {
-                               return sock->type;
-                       }
-               }               
-       }
-       return -1;
-}
-
-static void node_delete_reconnect(bNodeTree* tree, bNode* node) 
-{
-       bNodeLink *link, *next, *first = NULL;
-       bNodeSocket *valsocket= NULL, *colsocket= NULL, *vecsocket= NULL;
-       bNodeSocket *deliveringvalsocket= NULL, *deliveringcolsocket= NULL, *deliveringvecsocket= NULL;
-       bNode *deliveringvalnode= NULL, *deliveringcolnode= NULL, *deliveringvecnode= NULL;
-       bNodeSocket *sock;
-       int type;
-       int numberOfConnectedOutputSockets = 0;
-       int numberOfReconnections = 0;
-       int numberOfConnectedInputSockets = 0;
-
-       /* 
-               test the inputs, not really correct when a node has multiple input sockets of the same type
-               the first link evaluated will be used to determine the possible connection.
-       */
-       for(link= tree->links.first; link; link=link->next) {
-               if (link->tonode == node)  { numberOfConnectedInputSockets++; }
-               type = is_connected_to_input_socket(node, link);
-               switch (type) {
-               case SOCK_RGBA:
-                       if (colsocket == NULL) {
-                               colsocket = link->tosock;
-                               deliveringcolnode = link->fromnode;
-                               deliveringcolsocket = link->fromsock;
-                       }
-                       break;
-               case SOCK_VECTOR:
-                       if (vecsocket == NULL) {
-                               vecsocket = link->tosock;
-                               deliveringvecnode = link->fromnode;
-                               deliveringvecsocket = link->fromsock;
-                       }
-                       break;
-               case SOCK_FLOAT:
-                       if (valsocket == NULL) {
-                               valsocket = link->tosock;
-                               deliveringvalnode = link->fromnode;
-                               deliveringvalsocket = link->fromsock;
-                       }
-                       break;
-               default:
-                       break;
-               }
-       }
-       
-       // we now have the sockets+nodes that fill the inputsockets be aware for group nodes these can be NULL
-       // now make the links for all outputlinks of the node to be reconnected
-       for(link= tree->links.first; link; link=next) {
-               next= link->next;
-               if (link->fromnode == node) {
-                       sock = link->fromsock;
-                       numberOfConnectedOutputSockets ++;
-                       if (!first) first = link;
-                       switch(sock->type) {
-                       case SOCK_FLOAT:
-                               if (deliveringvalsocket) {
-                                       link->fromnode = deliveringvalnode;
-                                       link->fromsock = deliveringvalsocket;
-                                       numberOfReconnections++;
-                               }
-                               break;
-                       case SOCK_VECTOR:
-                               if (deliveringvecsocket) {
-                                       link->fromnode = deliveringvecnode;
-                                       link->fromsock = deliveringvecsocket;
-                                       numberOfReconnections++;
-                               }
-                               break;
-                       case SOCK_RGBA:
-                               if (deliveringcolsocket) {
-                                       link->fromnode = deliveringcolnode;
-                                       link->fromsock = deliveringcolsocket;
-                                       numberOfReconnections++;
-                               }
-                               break;
-                       }
-               }
-       }
-
-       /* when no connections have been made, and if only one delivering input socket type and one output socket we will connect those two */
-       if (numberOfConnectedOutputSockets == 1 && numberOfReconnections == 0 && numberOfConnectedInputSockets == 1) {
-               if (deliveringcolsocket) {
-                       first->fromnode = deliveringcolnode;
-                       first->fromsock = deliveringcolsocket;
-               } else if (deliveringvecsocket) {
-                       first->fromnode = deliveringvecnode;
-                       first->fromsock = deliveringvecsocket;
-               } else if (deliveringvalsocket) {
-                       first->fromnode = deliveringvalnode;
-                       first->fromsock = deliveringvalsocket;
-               }
-       }
-
-       if(node->id)
-               node->id->us--;
-       nodeFreeNode(tree, node);
-}
-
 static int node_delete_reconnect_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node, *next;
 
        ED_preview_kill_jobs(C);
 
-       for(node= snode->edittree->nodes.first; node; node= next) {
-               next= node->next;
-               if(node->flag & SELECT) {
-                       node_delete_reconnect(snode->edittree, node);
+       for (node = snode->edittree->nodes.first; node; node = next) {
+               next = node->next;
+               if (node->flag & SELECT) {
+                       nodeInternalRelink(snode->edittree, node);
+                       
+                       /* check id user here, nodeFreeNode is called for free dbase too */
+                       if (node->id)
+                               node->id->us--;
+                       nodeFreeNode(snode->edittree, node);
                }
        }
 
@@ -3383,23 +4237,23 @@ static int node_delete_reconnect_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_delete_reconnect(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Delete with reconnect";
+       ot->name = "Delete with reconnect";
        ot->description = "Delete nodes; will reconnect nodes as if deletion was muted";
-       ot->idname= "NODE_OT_delete_reconnect";
+       ot->idname = "NODE_OT_delete_reconnect";
 
        /* api callbacks */
-       ot->exec= node_delete_reconnect_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_delete_reconnect_exec;
+       ot->poll = ED_operator_node_active;
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ****************** Show Cyclic Dependencies Operator  ******************* */
 
 static int node_show_cycles_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       SpaceNode *snode= CTX_wm_space_node(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        
        /* this is just a wrapper around this call... */
        ntreeUpdateTree(snode->nodetree);
@@ -3411,53 +4265,49 @@ static int node_show_cycles_exec(bContext *C, wmOperator *UNUSED(op))
 void NODE_OT_show_cyclic_dependencies(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Show Cyclic Dependencies";
-       ot->description= "Sort the nodes and show the cyclic dependencies between the nodes";
-       ot->idname= "NODE_OT_show_cyclic_dependencies";
+       ot->name = "Show Cyclic Dependencies";
+       ot->description = "Sort the nodes and show the cyclic dependencies between the nodes";
+       ot->idname = "NODE_OT_show_cyclic_dependencies";
        
        /* callbacks */
-       ot->exec= node_show_cycles_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = node_show_cycles_exec;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* ****************** Add File Node Operator  ******************* */
 
 static int node_add_file_exec(bContext *C, wmOperator *op)
 {
-       Main *bmain= CTX_data_main(C);
-       Scene *scene= CTX_data_scene(C);
-       SpaceNode *snode= CTX_wm_space_node(C);
+       Main *bmain = CTX_data_main(C);
+       Scene *scene = CTX_data_scene(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        bNode *node;
-       Image *ima= NULL;
+       Image *ima = NULL;
        bNodeTemplate ntemp;
 
-       ntemp.type = -1;
-
        /* check input variables */
-       if (RNA_struct_property_is_set(op->ptr, "filepath"))
-       {
+       if (RNA_struct_property_is_set(op->ptr, "filepath")) {
                char path[FILE_MAX];
                RNA_string_get(op->ptr, "filepath", path);
 
-               errno= 0;
+               errno = 0;
 
-               ima= BKE_add_image_file(path);
+               ima = BKE_image_load_exists(path);
 
-               if(!ima) {
+               if (!ima) {
                        BKE_reportf(op->reports, RPT_ERROR, "Can't read: \"%s\", %s", path, errno ? strerror(errno) : "Unsupported image format");
                        return OPERATOR_CANCELLED;
                }
        }
-       else if(RNA_struct_property_is_set(op->ptr, "name"))
-       {
-               char name[MAX_ID_NAME-2];
+       else if (RNA_struct_property_is_set(op->ptr, "name")) {
+               char name[MAX_ID_NAME - 2];
                RNA_string_get(op->ptr, "name", name);
-               ima= (Image *)find_id("IM", name);
+               ima = (Image *)BKE_libblock_find_name(ID_IM, name);
 
-               if(!ima) {
+               if (!ima) {
                        BKE_reportf(op->reports, RPT_ERROR, "Image named \"%s\", not found", name);
                        return OPERATOR_CANCELLED;
                }
@@ -3465,12 +4315,20 @@ static int node_add_file_exec(bContext *C, wmOperator *op)
        
        node_deselect_all(snode);
        
-       if (snode->nodetree->type==NTREE_COMPOSIT)
-               ntemp.type = CMP_NODE_IMAGE;
-
-       if (ntemp.type < 0)
-               return OPERATOR_CANCELLED;
-               
+       switch (snode->nodetree->type) {
+               case NTREE_SHADER:
+                       ntemp.type = SH_NODE_TEX_IMAGE;
+                       break;
+               case NTREE_TEXTURE:
+                       ntemp.type = TEX_NODE_IMAGE;
+                       break;
+               case NTREE_COMPOSIT:
+                       ntemp.type = CMP_NODE_IMAGE;
+                       break;
+               default:
+                       return OPERATOR_CANCELLED;
+       }
+       
        ED_preview_kill_jobs(C);
        
        node = node_add_node(snode, bmain, scene, &ntemp, snode->mx, snode->my);
@@ -3490,12 +4348,12 @@ static int node_add_file_exec(bContext *C, wmOperator *op)
 
 static int node_add_file_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       ARegion *ar= CTX_wm_region(C);
-       SpaceNode *snode= CTX_wm_space_node(C);
+       ARegion *ar = CTX_wm_region(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
        
        /* convert mouse coordinates to v2d space */
        UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1],
-                                                        &snode->mx, &snode->my);
+                                &snode->mx, &snode->my);
        
        if (RNA_struct_property_is_set(op->ptr, "filepath") || RNA_struct_property_is_set(op->ptr, "name"))
                return node_add_file_exec(C, op);
@@ -3506,20 +4364,20 @@ static int node_add_file_invoke(bContext *C, wmOperator *op, wmEvent *event)
 void NODE_OT_add_file(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Add File Node";
-       ot->description= "Add a file node to the current node editor";
-       ot->idname= "NODE_OT_add_file";
+       ot->name = "Add File Node";
+       ot->description = "Add a file node to the current node editor";
+       ot->idname = "NODE_OT_add_file";
        
        /* callbacks */
-       ot->exec= node_add_file_exec;
-       ot->invoke= node_add_file_invoke;
-       ot->poll= composite_node_active;
+       ot->exec = node_add_file_exec;
+       ot->invoke = node_add_file_invoke;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE, FILE_SPECIAL, FILE_OPENFILE, WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);  //XXX TODO, relative_path
-       RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME-2, "Name", "Datablock name to assign");
+       WM_operator_properties_filesel(ot, FOLDERFILE | IMAGEFILE, FILE_SPECIAL, FILE_OPENFILE, WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);  //XXX TODO, relative_path
+       RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME - 2, "Name", "Datablock name to assign");
 }
 
 /********************** New node tree operator *********************/
@@ -3531,10 +4389,10 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
        PointerRNA ptr, idptr;
        PropertyRNA *prop;
        int treetype;
-       char treename[MAX_ID_NAME-2] = "NodeTree";
+       char treename[MAX_ID_NAME - 2] = "NodeTree";
        
        /* retrieve state */
-       snode= CTX_wm_space_node(C);
+       snode = CTX_wm_space_node(C);
        
        if (RNA_struct_property_is_set(op->ptr, "type"))
                treetype = RNA_enum_get(op->ptr, "type");
@@ -3545,13 +4403,13 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
                RNA_string_get(op->ptr, "name", treename);
        
        ntree = ntreeAddTree(treename, treetype, 0);
-       if(!ntree)
+       if (!ntree)
                return OPERATOR_CANCELLED;
        
        /* hook into UI */
        uiIDContextProperty(C, &ptr, &prop);
 
-       if(prop) {
+       if (prop) {
                RNA_id_pointer_create(&ntree->id, &idptr);
                RNA_property_pointer_set(&ptr, prop, idptr);
                /* RNA_property_pointer_set increases the user count,
@@ -3560,8 +4418,8 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
                --ntree->id.us;
                RNA_property_update(C, &ptr, prop);
        }
-       else if(snode) {
-               Scene *scene= CTX_data_scene(C);
+       else if (snode) {
+               Scene *scene = CTX_data_scene(C);
                snode->nodetree = ntree;
                
                ED_node_tree_update(snode, scene);
@@ -3573,16 +4431,514 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
 void NODE_OT_new_node_tree(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "New node tree";
-       ot->idname= "NODE_OT_new_node_tree";
+       ot->name = "New Node Tree";
+       ot->idname = "NODE_OT_new_node_tree";
+       ot->description = "Create a new node tree";
        
        /* api callbacks */
-       ot->exec= new_node_tree_exec;
-       ot->poll= ED_operator_node_active;
+       ot->exec = new_node_tree_exec;
+       ot->poll = ED_operator_node_active;
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
        RNA_def_enum(ot->srna, "type", nodetree_type_items, NTREE_COMPOSIT, "Tree Type", "");
-       RNA_def_string(ot->srna, "name", "NodeTree", MAX_ID_NAME-2, "Name", "");
+       RNA_def_string(ot->srna, "name", "NodeTree", MAX_ID_NAME - 2, "Name", "");
+}
+
+/* ****************** File Output Add Socket  ******************* */
+
+static int node_output_file_add_socket_exec(bContext *C, wmOperator *op)
+{
+       Scene *scene = CTX_data_scene(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       PointerRNA ptr;
+       bNodeTree *ntree;
+       bNode *node;
+       char file_path[MAX_NAME];
+       
+       ptr = CTX_data_pointer_get(C, "node");
+       if (!ptr.data)
+               return OPERATOR_CANCELLED;
+       node = ptr.data;
+       ntree = ptr.id.data;
+       
+       RNA_string_get(op->ptr, "file_path", file_path);
+       ntreeCompositOutputFileAddSocket(ntree, node, file_path, &scene->r.im_format);
+       
+       snode_notify(C, snode);
+       
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_output_file_add_socket(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Add File Node Socket";
+       ot->description = "Add a new input to a file output node";
+       ot->idname = "NODE_OT_output_file_add_socket";
+       
+       /* callbacks */
+       ot->exec = node_output_file_add_socket_exec;
+       ot->poll = composite_node_active;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       
+       RNA_def_string(ot->srna, "file_path", "Image", MAX_NAME, "File Path", "Sub-path of the output file");
+}
+
+/* ****************** Multi File Output Remove Socket  ******************* */
+
+static int node_output_file_remove_active_socket_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       PointerRNA ptr = CTX_data_pointer_get(C, "node");
+       bNodeTree *ntree;
+       bNode *node;
+       
+       if (!ptr.data)
+               return OPERATOR_CANCELLED;
+       node = ptr.data;
+       ntree = ptr.id.data;
+       
+       if (!ntreeCompositOutputFileRemoveActiveSocket(ntree, node))
+               return OPERATOR_CANCELLED;
+       
+       snode_notify(C, snode);
+       
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_output_file_remove_active_socket(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Remove File Node Socket";
+       ot->description = "Remove active input from a file output node";
+       ot->idname = "NODE_OT_output_file_remove_active_socket";
+       
+       /* callbacks */
+       ot->exec = node_output_file_remove_active_socket_exec;
+       ot->poll = composite_node_active;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Multi File Output Move Socket  ******************* */
+
+static int node_output_file_move_active_socket_exec(bContext *C, wmOperator *op)
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       PointerRNA ptr = CTX_data_pointer_get(C, "node");
+       bNode *node;
+       NodeImageMultiFile *nimf;
+       bNodeSocket *sock;
+       int direction;
+       
+       if (!ptr.data)
+               return OPERATOR_CANCELLED;
+       node = ptr.data;
+       nimf = node->storage;
+       
+       sock = BLI_findlink(&node->inputs, nimf->active_input);
+       if (!sock)
+               return OPERATOR_CANCELLED;
+       
+       direction = RNA_enum_get(op->ptr, "direction");
+       
+       if (direction == 1) {
+               bNodeSocket *before = sock->prev;
+               if (!before)
+                       return OPERATOR_CANCELLED;
+               BLI_remlink(&node->inputs, sock);
+               BLI_insertlinkbefore(&node->inputs, before, sock);
+               --nimf->active_input;
+       }
+       else {
+               bNodeSocket *after = sock->next;
+               if (!after)
+                       return OPERATOR_CANCELLED;
+               BLI_remlink(&node->inputs, sock);
+               BLI_insertlinkafter(&node->inputs, after, sock);
+               ++nimf->active_input;
+       }
+       
+       snode_notify(C, snode);
+       
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_output_file_move_active_socket(wmOperatorType *ot)
+{
+       static EnumPropertyItem direction_items[] = {
+               {1, "UP", 0, "Up", ""},
+               {2, "DOWN", 0, "Down", ""},
+               { 0, NULL, 0, NULL, NULL }
+       };
+       
+       /* identifiers */
+       ot->name = "Move File Node Socket";
+       ot->description = "Move the active input of a file output node up or down the list";
+       ot->idname = "NODE_OT_output_file_move_active_socket";
+       
+       /* callbacks */
+       ot->exec = node_output_file_move_active_socket_exec;
+       ot->poll = composite_node_active;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       
+       RNA_def_enum(ot->srna, "direction", direction_items, 2, "Direction", "");
+}
+
+/* ****************** Copy Node Color ******************* */
+
+static int node_copy_color_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *node, *tnode;
+       
+       if (!ntree)
+               return OPERATOR_CANCELLED;
+       node = nodeGetActive(ntree);
+       if (!node)
+               return OPERATOR_CANCELLED;
+       
+       for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
+               if (tnode->flag & NODE_SELECT && tnode != node) {
+                       if (node->flag & NODE_CUSTOM_COLOR) {
+                               tnode->flag |= NODE_CUSTOM_COLOR;
+                               copy_v3_v3(tnode->color, node->color);
+                       }
+                       else
+                               tnode->flag &= ~NODE_CUSTOM_COLOR;
+               }
+       }
+
+       ED_node_sort(ntree);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_node_copy_color(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Copy Color";
+       ot->description = "Copy color to all selected nodes";
+       ot->idname = "NODE_OT_node_copy_color";
+
+       /* api callbacks */
+       ot->exec = node_copy_color_exec;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Set Parent ******************* */
+
+static int node_parent_set_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *frame = nodeGetActive(ntree), *node;
+       if (!frame || frame->type != NODE_FRAME)
+               return OPERATOR_CANCELLED;
+       
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node == frame)
+                       continue;
+               if (node->flag & NODE_SELECT) {
+                       nodeDetachNode(node);
+                       nodeAttachNode(node, frame);
+               }
+       }
+
+       ED_node_sort(ntree);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_parent_set(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Make Parent";
+       ot->description = "Attach selected nodes";
+       ot->idname = "NODE_OT_parent_set";
+
+       /* api callbacks */
+       ot->exec = node_parent_set_exec;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Clear Parent ******************* */
+
+static int node_parent_clear_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *node;
+       
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & NODE_SELECT) {
+                       nodeDetachNode(node);
+               }
+       }
+
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_parent_clear(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Clear Parent";
+       ot->description = "Detach selected nodes";
+       ot->idname = "NODE_OT_parent_clear";
+
+       /* api callbacks */
+       ot->exec = node_parent_clear_exec;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Join Nodes ******************* */
+
+/* tags for depth-first search */
+#define NODE_JOIN_DONE          1
+#define NODE_JOIN_IS_DESCENDANT 2
+
+static void node_join_attach_recursive(bNode *node, bNode *frame)
+{
+       node->done |= NODE_JOIN_DONE;
+       
+       if (node == frame) {
+               node->done |= NODE_JOIN_IS_DESCENDANT;
+       }
+       else if (node->parent) {
+               /* call recursively */
+               if (!(node->parent->done & NODE_JOIN_DONE))
+                       node_join_attach_recursive(node->parent, frame);
+               
+               /* in any case: if the parent is a descendant, so is the child */
+               if (node->parent->done & NODE_JOIN_IS_DESCENDANT)
+                       node->done |= NODE_JOIN_IS_DESCENDANT;
+               else if (node->flag & NODE_TEST) {
+                       /* if parent is not an decendant of the frame, reattach the node */
+                       nodeDetachNode(node);
+                       nodeAttachNode(node, frame);
+                       node->done |= NODE_JOIN_IS_DESCENDANT;
+               }
+       }
+       else if (node->flag & NODE_TEST) {
+               nodeAttachNode(node, frame);
+               node->done |= NODE_JOIN_IS_DESCENDANT;
+       }
+}
+
+static int node_join_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       Main *bmain = CTX_data_main(C);
+       Scene *scene = CTX_data_scene(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *node, *frame;
+       bNodeTemplate ntemp;
+       
+       /* XXX save selection: node_add_node call below sets the new frame as single active+selected node */
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & NODE_SELECT)
+                       node->flag |= NODE_TEST;
+               else
+                       node->flag &= ~NODE_TEST;
+       }
+       
+       ntemp.main = bmain;
+       ntemp.scene = scene;
+       ntemp.type = NODE_FRAME;
+       frame = node_add_node(snode, bmain, scene, &ntemp, 0.0f, 0.0f);
+       
+       /* reset tags */
+       for (node = ntree->nodes.first; node; node = node->next)
+               node->done = 0;
+       
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (!(node->done & NODE_JOIN_DONE))
+                       node_join_attach_recursive(node, frame);
+       }
+
+       /* restore selection */
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (node->flag & NODE_TEST)
+                       node->flag |= NODE_SELECT;
+       }
+
+       ED_node_sort(ntree);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_join(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Join Nodes";
+       ot->description = "Attach selected nodes to a new common frame";
+       ot->idname = "NODE_OT_join";
+
+       /* api callbacks */
+       ot->exec = node_join_exec;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Attach ******************* */
+
+static int node_attach_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *frame;
+       
+       /* check nodes front to back */
+       for (frame = ntree->nodes.last; frame; frame = frame->prev) {
+               /* skip selected, those are the nodes we want to attach */
+               if ((frame->type != NODE_FRAME) || (frame->flag & NODE_SELECT))
+                       continue;
+               if (BLI_in_rctf(&frame->totr, snode->mx, snode->my))
+                       break;
+       }
+       if (frame) {
+               bNode *node, *parent;
+               for (node = ntree->nodes.last; node; node = node->prev) {
+                       if (node->flag & NODE_SELECT) {
+                               if (node->parent == NULL) {
+                                       /* attach all unparented nodes */
+                                       nodeAttachNode(node, frame);
+                               }
+                               else {
+                                       /* attach nodes which share parent with the frame */
+                                       for (parent = frame->parent; parent; parent = parent->parent)
+                                               if (parent == node->parent)
+                                                       break;
+                                       if (parent) {
+                                               nodeDetachNode(node);
+                                               nodeAttachNode(node, frame);
+                                       }
+                               }
+                       }
+               }
+       }
+       
+       ED_node_sort(ntree);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+       
+       return OPERATOR_FINISHED;
+}
+
+static int node_attach_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+       ARegion *ar = CTX_wm_region(C);
+       SpaceNode *snode = CTX_wm_space_node(C);
+       
+       /* convert mouse coordinates to v2d space */
+       UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &snode->mx, &snode->my);
+       
+       return node_attach_exec(C, op);
+}
+
+void NODE_OT_attach(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Attach Nodes";
+       ot->description = "Attach active node to a frame";
+       ot->idname = "NODE_OT_attach";
+
+       /* api callbacks */
+       ot->exec = node_attach_exec;
+       ot->invoke = node_attach_invoke;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ****************** Detach ******************* */
+
+/* tags for depth-first search */
+#define NODE_DETACH_DONE            1
+#define NODE_DETACH_IS_DESCENDANT   2
+
+static void node_detach_recursive(bNode *node)
+{
+       node->done |= NODE_DETACH_DONE;
+       
+       if (node->parent) {
+               /* call recursively */
+               if (!(node->parent->done & NODE_DETACH_DONE))
+                       node_detach_recursive(node->parent);
+               
+               /* in any case: if the parent is a descendant, so is the child */
+               if (node->parent->done & NODE_DETACH_IS_DESCENDANT)
+                       node->done |= NODE_DETACH_IS_DESCENDANT;
+               else if (node->flag & NODE_SELECT) {
+                       /* if parent is not a decendant of a selected node, detach */
+                       nodeDetachNode(node);
+                       node->done |= NODE_DETACH_IS_DESCENDANT;
+               }
+       }
+       else if (node->flag & NODE_SELECT) {
+               node->done |= NODE_DETACH_IS_DESCENDANT;
+       }
+}
+
+/* detach the root nodes in the current selection */
+static int node_detach_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       SpaceNode *snode = CTX_wm_space_node(C);
+       bNodeTree *ntree = snode->edittree;
+       bNode *node;
+       
+       /* reset tags */
+       for (node = ntree->nodes.first; node; node = node->next)
+               node->done = 0;
+       /* detach nodes recursively
+        * relative order is preserved here!
+        */
+       for (node = ntree->nodes.first; node; node = node->next) {
+               if (!(node->done & NODE_DETACH_DONE))
+                       node_detach_recursive(node);
+       }
+       
+       ED_node_sort(ntree);
+       WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, NULL);
+       
+       return OPERATOR_FINISHED;
+}
+
+void NODE_OT_detach(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Detach Nodes";
+       ot->description = "Detach selected nodes from parents";
+       ot->idname = "NODE_OT_detach";
+
+       /* api callbacks */
+       ot->exec = node_detach_exec;
+       ot->poll = ED_operator_node_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }