6114323ff02999ae7d32eb07e8717877ad77f587
[blender.git] / source / blender / editors / space_node / node_header.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008 Blender Foundation.
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_node/node_header.c
28  *  \ingroup spnode
29  */
30
31 #include <string.h>
32
33 #include "DNA_space_types.h"
34 #include "DNA_node_types.h"
35 #include "DNA_screen_types.h"
36
37 #include "MEM_guardedalloc.h"
38
39 #include "BLI_blenlib.h"
40 #include "BLI_utildefines.h"
41
42 #include "BLF_translation.h"
43
44 #include "BKE_context.h"
45 #include "BKE_global.h"
46 #include "BKE_main.h"
47 #include "BKE_node.h"
48 #include "BKE_scene.h"
49 #include "BKE_screen.h"
50
51 #include "WM_api.h"
52 #include "WM_types.h"
53
54 #include "UI_view2d.h"
55
56 #include "node_intern.h"  /* own include */
57
58 /* ************************ add menu *********************** */
59
60 static void do_node_add(bContext *C, bNodeTemplate *ntemp)
61 {
62         Main *bmain= CTX_data_main(C);
63         Scene *scene= CTX_data_scene(C);
64         SpaceNode *snode= CTX_wm_space_node(C);
65         ScrArea *sa= CTX_wm_area(C);
66         ARegion *ar;
67         bNode *node;
68         
69         /* get location to add node at mouse */
70         for (ar=sa->regionbase.first; ar; ar=ar->next) {
71                 if (ar->regiontype == RGN_TYPE_WINDOW) {
72                         wmWindow *win= CTX_wm_window(C);
73                         int x= win->eventstate->x - ar->winrct.xmin;
74                         int y= win->eventstate->y - ar->winrct.ymin;
75                         
76                         if (y < 60) y+= 60;
77                         UI_view2d_region_to_view(&ar->v2d, x, y, &snode->mx, &snode->my);
78                 }
79         }
80         
81         /* store selection in temp test flag */
82         for (node= snode->edittree->nodes.first; node; node= node->next) {
83                 if (node->flag & NODE_SELECT) node->flag |= NODE_TEST;
84                 else node->flag &= ~NODE_TEST;
85         }
86         
87         /* node= */ node_add_node(snode, bmain, scene, ntemp, snode->mx, snode->my);
88         
89         /* select previous selection before autoconnect */
90         for (node= snode->edittree->nodes.first; node; node= node->next) {
91                 if (node->flag & NODE_TEST) node->flag |= NODE_SELECT;
92         }
93         
94         /* deselect after autoconnection */
95         for (node= snode->edittree->nodes.first; node; node= node->next) {
96                 if (node->flag & NODE_TEST) node->flag &= ~NODE_SELECT;
97         }
98                 
99         snode_notify(C, snode);
100         snode_dag_update(C, snode);
101 }
102
103 static void do_node_add_static(bContext *C, void *UNUSED(arg), int event)
104 {
105         Main *bmain = CTX_data_main(C);
106         Scene *scene = CTX_data_scene(C);
107         bNodeTemplate ntemp;
108         
109         ntemp.type = event;
110         ntemp.main = bmain;
111         ntemp.scene = scene;
112         
113         do_node_add(C, &ntemp);
114 }
115
116 static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
117 {
118         SpaceNode *snode= CTX_wm_space_node(C);
119         Main *bmain = CTX_data_main(C);
120         Scene *scene = CTX_data_scene(C);
121         bNodeTemplate ntemp;
122         
123         if (event>=0) {
124                 ntemp.ngroup= BLI_findlink(&G.main->nodetree, event);
125                 ntemp.type = ntemp.ngroup->nodetype;
126         }
127         else {
128                 ntemp.type = -event;
129                 switch (ntemp.type) {
130                 case NODE_GROUP:
131                         ntemp.ngroup = ntreeAddTree("Group", snode->treetype, ntemp.type);
132                         break;
133                 case NODE_FORLOOP:
134                         ntemp.ngroup = ntreeAddTree("For Loop", snode->treetype, ntemp.type);
135                         break;
136                 case NODE_WHILELOOP:
137                         ntemp.ngroup = ntreeAddTree("While Loop", snode->treetype, ntemp.type);
138                         break;
139                 default:
140                         ntemp.ngroup = NULL;
141                 }
142         }
143         if (!ntemp.ngroup)
144                 return;
145         
146         ntemp.main = bmain;
147         ntemp.scene = scene;
148         
149         do_node_add(C, &ntemp);
150 }
151
152 static int node_tree_has_type(int treetype, int nodetype)
153 {
154         bNodeTreeType *ttype= ntreeGetType(treetype);
155         bNodeType *ntype;
156         for (ntype=ttype->node_types.first; ntype; ntype=ntype->next) {
157                 if (ntype->type==nodetype)
158                         return 1;
159         }
160         return 0;
161 }
162
163 static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass)
164 {
165         Main *bmain= CTX_data_main(C);
166         Scene *scene= CTX_data_scene(C);
167         SpaceNode *snode= CTX_wm_space_node(C);
168         bNodeTree *ntree;
169         int nodeclass= GET_INT_FROM_POINTER(arg_nodeclass);
170         int event, compatibility= 0;
171         
172         ntree = snode->nodetree;
173         
174         if (!ntree) {
175                 uiItemS(layout);
176                 return;
177         }
178
179         if (ntree->type == NTREE_SHADER) {
180                 if (BKE_scene_use_new_shading_nodes(scene))
181                         compatibility= NODE_NEW_SHADING;
182                 else
183                         compatibility= NODE_OLD_SHADING;
184         }
185         
186         if (nodeclass==NODE_CLASS_GROUP) {
187                 bNodeTree *ngroup;
188                 
189                 uiLayoutSetFunc(layout, do_node_add_group, NULL);
190                 
191                 /* XXX hack: negative numbers used for empty group types */
192                 if (node_tree_has_type(ntree->type, NODE_GROUP))
193                         uiItemV(layout, IFACE_("New Group"), 0, -NODE_GROUP);
194                 if (node_tree_has_type(ntree->type, NODE_FORLOOP))
195                         uiItemV(layout, IFACE_("New For Loop"), 0, -NODE_FORLOOP);
196                 if (node_tree_has_type(ntree->type, NODE_WHILELOOP))
197                         uiItemV(layout, IFACE_("New While Loop"), 0, -NODE_WHILELOOP);
198                 uiItemS(layout);
199                 
200                 for (ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) {
201                         /* only use group trees */
202                         if (ngroup->type==ntree->type && ELEM3(ngroup->nodetype, NODE_GROUP, NODE_FORLOOP, NODE_WHILELOOP)) {
203                                 uiItemV(layout, ngroup->id.name+2, 0, event);
204                         }
205                 }
206         }
207         else {
208                 bNodeType *ntype;
209                 
210                 uiLayoutSetFunc(layout, do_node_add_static, NULL);
211                 
212                 for (ntype=ntreeGetType(ntree->type)->node_types.first; ntype; ntype=ntype->next) {
213                         if (ntype->nclass==nodeclass && ntype->name)
214                                 if (!compatibility || (ntype->compatibility & compatibility))
215                                         uiItemV(layout, IFACE_(ntype->name), 0, ntype->type);
216                 }
217         }
218 }
219
220 static void node_menu_add_foreach_cb(void *calldata, int nclass, const char *name)
221 {
222         uiLayout *layout= calldata;
223         uiItemMenuF(layout, IFACE_(name), 0, node_add_menu, SET_INT_IN_POINTER(nclass));
224 }
225
226 static void node_menu_add(const bContext *C, Menu *menu)
227 {
228         Scene *scene= CTX_data_scene(C);
229         SpaceNode *snode= CTX_wm_space_node(C);
230         uiLayout *layout= menu->layout;
231         bNodeTreeType *ntreetype= ntreeGetType(snode->treetype);
232
233         if (!snode->nodetree)
234                 uiLayoutSetActive(layout, FALSE);
235         
236         if (ntreetype && ntreetype->foreach_nodeclass)
237                 ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb);
238 }
239
240 void node_menus_register(void)
241 {
242         MenuType *mt;
243
244         mt= MEM_callocN(sizeof(MenuType), "spacetype node menu add");
245         strcpy(mt->idname, "NODE_MT_add");
246         strcpy(mt->label, "Add");
247         mt->draw= node_menu_add;
248         WM_menutype_add(mt);
249 }