Renamed the mx/my coordinates in SpaceNode to more descriptive 'cursor'. This follows...
[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->cursor[0], &snode->cursor[1]);
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->cursor[0], snode->cursor[1]);
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 }
221
222 static void node_menu_add_foreach_cb(void *calldata, int nclass, const char *name)
223 {
224         uiLayout *layout = calldata;
225         uiItemMenuF(layout, IFACE_(name), 0, node_add_menu, SET_INT_IN_POINTER(nclass));
226 }
227
228 static void node_menu_add(const bContext *C, Menu *menu)
229 {
230         Scene *scene = CTX_data_scene(C);
231         SpaceNode *snode = CTX_wm_space_node(C);
232         uiLayout *layout = menu->layout;
233         bNodeTreeType *ntreetype = ntreeGetType(snode->treetype);
234
235         if (!snode->nodetree)
236                 uiLayoutSetActive(layout, FALSE);
237         
238         uiLayoutSetOperatorContext(layout, WM_OP_INVOKE_DEFAULT);
239         uiItemO(layout, "Search ...", 0, "NODE_OT_add_search");
240         
241         if (ntreetype && ntreetype->foreach_nodeclass)
242                 ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb);
243 }
244
245 void node_menus_register(void)
246 {
247         MenuType *mt;
248
249         mt = MEM_callocN(sizeof(MenuType), "spacetype node menu add");
250         strcpy(mt->idname, "NODE_MT_add");
251         strcpy(mt->label, "Add");
252         mt->draw = node_menu_add;
253         WM_menutype_add(mt);
254 }