Fix syntax for ID keyword.
[blender-staging.git] / source / blender / editors / space_node / node_select.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2008 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation, Nathan Letwory
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <stdio.h>
30
31 #include "DNA_node_types.h"
32 #include "DNA_material_types.h"
33 #include "DNA_texture_types.h"
34 #include "DNA_scene_types.h"
35 #include "DNA_screen_types.h"
36 #include "DNA_space_types.h"
37
38 #include "BKE_context.h"
39 #include "BKE_node.h"
40 #include "BKE_global.h"
41 #include "BKE_utildefines.h"
42
43 #include "BLI_rect.h"
44
45 #include "ED_space_api.h"
46 #include "ED_screen.h"
47 #include "ED_types.h"
48
49 #include "RNA_access.h"
50 #include "RNA_define.h"
51
52 #include "WM_api.h"
53 #include "WM_types.h"
54
55 #include "UI_view2d.h"
56  
57 #include "node_intern.h"
58
59 /* ****** helpers ****** */
60
61 static bNode *node_under_mouse(bNodeTree *ntree, int mx, int my)
62 {
63         bNode *node;
64         
65         for(next_node(ntree); (node=next_node(NULL));) {
66                 /* node body (header and scale are in other operators) */
67                 if (BLI_in_rctf(&node->totr, mx, my))
68                         return node;
69         }
70         return NULL;
71 }
72
73 /* ****** Click Select ****** */
74  
75 static bNode *node_mouse_select(SpaceNode *snode, ARegion *ar, short *mval, short extend)
76 {
77         bNode *node;
78         float mx, my;
79         
80         /* get mouse coordinates in view2d space */
81         mx= (float)mval[0];
82         my= (float)mval[1];
83         
84         UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &mx, &my);
85         
86         /* find the closest visible node */
87         node = node_under_mouse(snode->edittree, mx, my);
88         
89         if (node) {
90                 if (extend == 0) {
91                         node_deselectall(snode);
92                         node->flag |= SELECT;
93                 }
94                 else
95                         node->flag ^= SELECT;
96                         
97                 node_set_active(snode, node);
98         }
99
100         return node;
101 }
102
103 static int node_select_exec(bContext *C, wmOperator *op)
104 {
105         SpaceNode *snode= CTX_wm_space_node(C);
106         ARegion *ar= CTX_wm_region(C);
107         short mval[2];
108         short extend;
109         bNode *node= NULL;
110         
111         /* get settings from RNA properties for operator */
112         mval[0] = RNA_int_get(op->ptr, "mouse_x");
113         mval[1] = RNA_int_get(op->ptr, "mouse_y");
114         
115         extend = RNA_boolean_get(op->ptr, "extend");
116         
117         /* perform the select */
118         node= node_mouse_select(snode, ar, mval, extend);
119
120         /* need refresh/a notifier vs compo notifier */
121         WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL); /* Do we need to pass the scene? */
122
123         /* WATCH THIS, there are a few other ways to change the active material */
124         if(node) {
125                 if (node->id && ELEM(GS(node->id->name), ID_MA, ID_TE)) {
126                         WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING_DRAW, node->id);
127                 }
128         }
129         
130     /* send notifiers */
131         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
132         
133         /* allow tweak event to work too */
134         return OPERATOR_FINISHED|OPERATOR_PASS_THROUGH;
135 }
136
137 static int node_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
138 {
139         ARegion *ar= CTX_wm_region(C);
140         short mval[2];  
141         
142         mval[0]= event->x - ar->winrct.xmin;
143         mval[1]= event->y - ar->winrct.ymin;
144         
145         RNA_int_set(op->ptr, "mouse_x", mval[0]);
146         RNA_int_set(op->ptr, "mouse_y", mval[1]);
147
148         return node_select_exec(C,op);
149 }
150
151
152 void NODE_OT_select(wmOperatorType *ot)
153 {
154         /* identifiers */
155         ot->name= "Select";
156         ot->idname= "NODE_OT_select";
157         
158         /* api callbacks */
159         ot->invoke= node_select_invoke;
160         ot->poll= ED_operator_node_active;
161         
162         /* flags */
163         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
164         
165         /* properties */
166         RNA_def_int(ot->srna, "mouse_x", 0, INT_MIN, INT_MAX, "Mouse X", "", INT_MIN, INT_MAX);
167         RNA_def_int(ot->srna, "mouse_y", 0, INT_MIN, INT_MAX, "Mouse Y", "", INT_MIN, INT_MAX);
168         RNA_def_boolean(ot->srna, "extend", 0, "Extend", "");
169 }
170
171 /* ****** Border Select ****** */
172
173 static int node_borderselect_exec(bContext *C, wmOperator *op)
174 {
175         SpaceNode *snode= CTX_wm_space_node(C);
176         ARegion *ar= CTX_wm_region(C);
177         bNode *node;
178         rcti rect;
179         rctf rectf;
180         int gesture_mode= RNA_int_get(op->ptr, "gesture_mode");
181         
182         rect.xmin= RNA_int_get(op->ptr, "xmin");
183         rect.ymin= RNA_int_get(op->ptr, "ymin");
184         UI_view2d_region_to_view(&ar->v2d, rect.xmin, rect.ymin, &rectf.xmin, &rectf.ymin);
185         
186         rect.xmax= RNA_int_get(op->ptr, "xmax");
187         rect.ymax= RNA_int_get(op->ptr, "ymax");
188         UI_view2d_region_to_view(&ar->v2d, rect.xmax, rect.ymax, &rectf.xmax, &rectf.ymax);
189         
190         for(node= snode->edittree->nodes.first; node; node= node->next) {
191                 if(BLI_isect_rctf(&rectf, &node->totr, NULL)) {
192                         if(gesture_mode==GESTURE_MODAL_SELECT)
193                                 node->flag |= SELECT;
194                         else
195                                 node->flag &= ~SELECT;
196                 }
197         }
198         
199         WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL); /* Do we need to pass the scene? */
200
201         return OPERATOR_FINISHED;
202 }
203
204 static int node_border_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
205 {
206         int tweak = RNA_boolean_get(op->ptr, "tweak");
207         
208         if (tweak) {
209                 /* prevent initiating the border select if the mouse is over a node */
210                 /* this allows border select on empty space, but drag-translate on nodes */
211                 SpaceNode *snode= CTX_wm_space_node(C);
212                 ARegion *ar= CTX_wm_region(C);
213                 short mval[2];
214                 float mx, my;
215                 
216                 mval[0]= event->x - ar->winrct.xmin;
217                 mval[1]= event->y - ar->winrct.ymin;
218                 
219                 /* get mouse coordinates in view2d space */
220                 mx= (float)mval[0];
221                 my= (float)mval[1];
222                 
223                 UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &mx, &my);
224                 
225                 if (node_under_mouse(snode->edittree, mx, my))
226                         return OPERATOR_CANCELLED|OPERATOR_PASS_THROUGH;
227         }
228         
229         return WM_border_select_invoke(C, op, event);
230 }
231
232 void NODE_OT_select_border(wmOperatorType *ot)
233 {
234         /* identifiers */
235         ot->name= "Border Select";
236         ot->idname= "NODE_OT_select_border";
237         
238         /* api callbacks */
239         ot->invoke= node_border_select_invoke;
240         ot->exec= node_borderselect_exec;
241         ot->modal= WM_border_select_modal;
242         
243         ot->poll= ED_operator_node_active;
244         
245         /* flags */
246         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
247         
248         /* rna */
249         WM_operator_properties_gesture_border(ot, FALSE);
250         RNA_def_boolean(ot->srna, "tweak", 0, "Tweak", "Only activate when mouse is not over a node - useful for tweak gesture");
251 }
252
253 /* ****** Select/Deselect All ****** */
254
255 static int node_select_all_exec(bContext *C, wmOperator *op)
256 {
257         SpaceNode *snode = CTX_wm_space_node(C);
258         bNode *first = snode->edittree->nodes.first;
259         bNode *node;
260         int count= 0;
261
262         for(node=first; node; node=node->next)
263                 if(node->flag & NODE_SELECT)
264                         count++;
265
266         if(count) {
267                 for(node=first; node; node=node->next)
268                         node->flag &= ~NODE_SELECT;
269         }
270         else {
271                 for(node=first; node; node=node->next)
272                         node->flag |= NODE_SELECT;
273         }
274         
275         WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL);
276         return OPERATOR_FINISHED;
277 }
278
279 void NODE_OT_select_all(wmOperatorType *ot)
280 {
281         /* identifiers */
282         ot->name = "Select/Deselect All";
283         ot->description = "(De)select all nodes";
284         ot->idname = "NODE_OT_select_all";
285         
286         /* api callbacks */
287         ot->exec = node_select_all_exec;
288         ot->poll = ED_operator_node_active;
289         
290         /* flags */
291         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
292 }
293
294 /* ****** Select Linked To ****** */
295
296 static int node_select_linked_to_exec(bContext *C, wmOperator *op)
297 {
298         SpaceNode *snode = CTX_wm_space_node(C);
299         bNodeLink *link;
300         bNode *node;
301         
302         for (node=snode->edittree->nodes.first; node; node=node->next)
303                 node->flag &= ~NODE_TEST;
304
305         for (link=snode->edittree->links.first; link; link=link->next) {
306                 if (link->fromnode->flag & NODE_SELECT)
307                         link->tonode->flag |= NODE_TEST;
308         }
309         
310         for (node=snode->edittree->nodes.first; node; node=node->next) {
311                 if (node->flag & NODE_TEST)
312                         node->flag |= NODE_SELECT;
313         }
314         
315         WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL);
316         return OPERATOR_FINISHED;
317 }
318
319 void NODE_OT_select_linked_to(wmOperatorType *ot)
320 {
321         /* identifiers */
322         ot->name = "Select Linked To";
323         ot->description = "Select nodes linked to the selected ones";
324         ot->idname = "NODE_OT_select_linked_to";
325         
326         /* api callbacks */
327         ot->exec = node_select_linked_to_exec;
328         ot->poll = ED_operator_node_active;
329         
330         /* flags */
331         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
332 }
333
334 /* ****** Select Linked From ****** */
335
336 static int node_select_linked_from_exec(bContext *C, wmOperator *op)
337 {
338         SpaceNode *snode = CTX_wm_space_node(C);
339         bNodeLink *link;
340         bNode *node;
341         
342         for(node=snode->edittree->nodes.first; node; node=node->next)
343                 node->flag &= ~NODE_TEST;
344
345         for(link=snode->edittree->links.first; link; link=link->next) {
346                 if(link->tonode->flag & NODE_SELECT)
347                         link->fromnode->flag |= NODE_TEST;
348         }
349         
350         for(node=snode->edittree->nodes.first; node; node=node->next) {
351                 if(node->flag & NODE_TEST)
352                         node->flag |= NODE_SELECT;
353         }
354         
355         WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL);
356         return OPERATOR_FINISHED;
357 }
358
359 void NODE_OT_select_linked_from(wmOperatorType *ot)
360 {
361         /* identifiers */
362         ot->name = "Select Linked From";
363         ot->description = "Select nodes linked from the selected ones";
364         ot->idname = "NODE_OT_select_linked_from";
365         
366         /* api callbacks */
367         ot->exec = node_select_linked_from_exec;
368         ot->poll = ED_operator_node_active;
369         
370         /* flags */
371         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
372 }
373