node_header.c

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. 
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2008 Blender Foundation.
 * All rights reserved.
 *
 * 
 * Contributor(s): Blender Foundation
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#include <string.h>
#include <stdio.h>

#include "DNA_space_types.h"
#include "DNA_node_types.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"

#include "MEM_guardedalloc.h"

#include "BLI_blenlib.h"
#include "BLI_utildefines.h"

#include "BLF_translation.h"

#include "BKE_context.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "BKE_scene.h"
#include "BKE_screen.h"

#include "RNA_access.h"

#include "WM_api.h"
#include "WM_types.h"

#include "UI_interface.h"
#include "UI_interface_icons.h"
#include "UI_resources.h"
#include "UI_view2d.h"

#include "node_intern.h"

/* ************************ add menu *********************** */

static void do_node_add(bContext *C, bNodeTemplate *ntemp)
{
    Main *bmain= CTX_data_main(C);
    Scene *scene= CTX_data_scene(C);
    SpaceNode *snode= CTX_wm_space_node(C);
    ScrArea *sa= CTX_wm_area(C);
    ARegion *ar;
    bNode *node;
    
    /* get location to add node at mouse */
    for(ar=sa->regionbase.first; ar; ar=ar->next) {
        if(ar->regiontype == RGN_TYPE_WINDOW) {
            wmWindow *win= CTX_wm_window(C);
            int x= win->eventstate->x - ar->winrct.xmin;
            int y= win->eventstate->y - ar->winrct.ymin;
            
            if(y < 60) y+= 60;
            UI_view2d_region_to_view(&ar->v2d, x, y, &snode->mx, &snode->my);
        }
    }
    
    /* store selection in temp test flag */
    for(node= snode->edittree->nodes.first; node; node= node->next) {
        if(node->flag & NODE_SELECT) node->flag |= NODE_TEST;
        else node->flag &= ~NODE_TEST;
    }
    
    /* node= */ node_add_node(snode, bmain, scene, ntemp, snode->mx, snode->my);
    
    /* select previous selection before autoconnect */
    for(node= snode->edittree->nodes.first; node; node= node->next) {
        if(node->flag & NODE_TEST) node->flag |= NODE_SELECT;
    }
    
    /* deselect after autoconnection */
    for(node= snode->edittree->nodes.first; node; node= node->next) {
        if(node->flag & NODE_TEST) node->flag &= ~NODE_SELECT;
    }
        
    snode_notify(C, snode);
    snode_dag_update(C, snode);
}

static void do_node_add_static(bContext *C, void *UNUSED(arg), int event)
{
    bNodeTemplate ntemp;
    ntemp.type = event;
    do_node_add(C, &ntemp);
}

static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
{
    SpaceNode *snode= CTX_wm_space_node(C);
    bNodeTemplate ntemp;
    
    if (event>=0) {
        ntemp.ngroup= BLI_findlink(&G.main->nodetree, event);
        ntemp.type = ntemp.ngroup->nodetype;
    }
    else {
        ntemp.type = -event;
        switch (ntemp.type) {
        case NODE_GROUP:
            ntemp.ngroup = ntreeAddTree("Group", snode->treetype, ntemp.type);
            break;
        case NODE_FORLOOP:
            ntemp.ngroup = ntreeAddTree("For Loop", snode->treetype, ntemp.type);
            break;
        case NODE_WHILELOOP:
            ntemp.ngroup = ntreeAddTree("While Loop", snode->treetype, ntemp.type);
            break;
        default:
            ntemp.ngroup = NULL;
        }
    }
    if (!ntemp.ngroup)
        return;
    
    do_node_add(C, &ntemp);
}

#if 0 /* disabled */
static void do_node_add_dynamic(bContext *C, void *UNUSED(arg), int event)
{
    bNodeTemplate ntemp;
    ntemp.type = NODE_DYNAMIC;
    do_node_add(C, &ntemp);
}
#endif

static int node_tree_has_type(int treetype, int nodetype)
{
    bNodeTreeType *ttype= ntreeGetType(treetype);
    bNodeType *ntype;
    for (ntype=ttype->node_types.first; ntype; ntype=ntype->next) {
        if (ntype->type==nodetype)
            return 1;
    }
    return 0;
}

static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass)
{
    Main *bmain= CTX_data_main(C);
    Scene *scene= CTX_data_scene(C);
    SpaceNode *snode= CTX_wm_space_node(C);
    bNodeTree *ntree;
    int nodeclass= GET_INT_FROM_POINTER(arg_nodeclass);
    int event, compatibility= 0;
    
    ntree = snode->nodetree;
    
    if(!ntree) {
        uiItemS(layout);
        return;
    }

    if(ntree->type == NTREE_SHADER) {
        if(scene_use_new_shading_nodes(scene))
            compatibility= NODE_NEW_SHADING;
        else
            compatibility= NODE_OLD_SHADING;
    }
    
    if (nodeclass==NODE_CLASS_GROUP) {
        bNodeTree *ngroup;
        
        uiLayoutSetFunc(layout, do_node_add_group, NULL);
        
        /* XXX hack: negative numbers used for empty group types */
        if (node_tree_has_type(ntree->type, NODE_GROUP))
            uiItemV(layout, "New Group", 0, -NODE_GROUP);
        if (node_tree_has_type(ntree->type, NODE_FORLOOP))
            uiItemV(layout, "New For Loop", 0, -NODE_FORLOOP);
        if (node_tree_has_type(ntree->type, NODE_WHILELOOP))
            uiItemV(layout, "New While Loop", 0, -NODE_WHILELOOP);
        uiItemS(layout);
        
        for(ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) {
            /* only use group trees */
            if (ngroup->type==ntree->type && ELEM3(ngroup->nodetype, NODE_GROUP, NODE_FORLOOP, NODE_WHILELOOP)) {
                uiItemV(layout, ngroup->id.name+2, 0, event);
            }
        }
    }
    else if (nodeclass==NODE_DYNAMIC) {
        /* disabled */
    }
    else {
        bNodeType *ntype;
        
        uiLayoutSetFunc(layout, do_node_add_static, NULL);
        
        for (ntype=ntreeGetType(ntree->type)->node_types.first; ntype; ntype=ntype->next) {
            if (ntype->nclass==nodeclass && ntype->name)
                if (!compatibility || (ntype->compatibility & compatibility))
                    uiItemV(layout, ntype->name, 0, ntype->type);
        }
    }
}

static void node_menu_add_foreach_cb(void *calldata, int nclass, const char *name)
{
    uiLayout *layout= calldata;
    uiItemMenuF(layout, name, 0, node_add_menu, SET_INT_IN_POINTER(nclass));
}

static void node_menu_add(const bContext *C, Menu *menu)
{
    Scene *scene= CTX_data_scene(C);
    SpaceNode *snode= CTX_wm_space_node(C);
    uiLayout *layout= menu->layout;
    bNodeTreeType *ntreetype= ntreeGetType(snode->treetype);

    if(!snode->nodetree)
        uiLayoutSetActive(layout, 0);
    
    if(ntreetype && ntreetype->foreach_nodeclass)
        ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb);
}

void node_menus_register(void)
{
    MenuType *mt;

    mt= MEM_callocN(sizeof(MenuType), "spacetype node menu add");
    strcpy(mt->idname, "NODE_MT_add");
    strcpy(mt->label, "Add");
    mt->draw= node_menu_add;
    WM_menutype_add(mt);
}