Node Space: Small feature for Venomgfx, Shift + F select node of the same type
[blender.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_scene_types.h"
33
34 #include "BKE_context.h"
35 #include "BKE_node.h"
36 #include "BKE_global.h"
37 #include "BKE_utildefines.h"
38
39 #include "BLI_rect.h"
40
41 #include "ED_screen.h"
42 #include "ED_types.h"
43
44 #include "RNA_access.h"
45 #include "RNA_define.h"
46
47 #include "WM_api.h"
48 #include "WM_types.h"
49
50 #include "UI_view2d.h"
51  
52 #include "node_intern.h"
53
54 /* ****** helpers ****** */
55
56 static bNode *node_under_mouse(bNodeTree *ntree, int mx, int my)
57 {
58         bNode *node;
59         
60         for(next_node(ntree); (node=next_node(NULL));) {
61                 /* node body (header and scale are in other operators) */
62                 if (BLI_in_rctf(&node->totr, mx, my))
63                         return node;
64         }
65         return NULL;
66 }
67
68 /* ****** Click Select ****** */
69  
70 static bNode *node_mouse_select(SpaceNode *snode, ARegion *ar, short *mval, short extend)
71 {
72         bNode *node;
73         float mx, my;
74         
75         /* get mouse coordinates in view2d space */
76         mx= (float)mval[0];
77         my= (float)mval[1];
78         
79         UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &mx, &my);
80         
81         /* find the closest visible node */
82         node = node_under_mouse(snode->edittree, mx, my);
83         
84         if (node) {
85                 if (extend == 0) {
86                         node_deselectall(snode);
87                         node->flag |= SELECT;
88                 }
89                 else
90                         node->flag ^= SELECT;
91                         
92                 node_set_active(snode, node);
93         }
94
95         return node;
96 }
97
98 static int node_select_exec(bContext *C, wmOperator *op)
99 {
100         SpaceNode *snode= CTX_wm_space_node(C);
101         ARegion *ar= CTX_wm_region(C);
102         short mval[2];
103         short extend;
104         bNode *node= NULL;
105         
106         /* get settings from RNA properties for operator */
107         mval[0] = RNA_int_get(op->ptr, "mouse_x");
108         mval[1] = RNA_int_get(op->ptr, "mouse_y");
109         
110         extend = RNA_boolean_get(op->ptr, "extend");
111         
112         /* perform the select */
113         node= node_mouse_select(snode, ar, mval, extend);
114
115         /* WATCH THIS, there are a few other ways to change the active material */
116         if(node) {
117                 if (node->id && ELEM(GS(node->id->name), ID_MA, ID_TE)) {
118                         WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING_DRAW, node->id);
119                 }
120         }
121         
122         /* send notifiers */
123         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
124         
125         /* allow tweak event to work too */
126         return OPERATOR_FINISHED|OPERATOR_PASS_THROUGH;
127 }
128
129 static int node_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
130 {
131         ARegion *ar= CTX_wm_region(C);
132         short mval[2];  
133         
134         mval[0]= event->x - ar->winrct.xmin;
135         mval[1]= event->y - ar->winrct.ymin;
136         
137         RNA_int_set(op->ptr, "mouse_x", mval[0]);
138         RNA_int_set(op->ptr, "mouse_y", mval[1]);
139
140         return node_select_exec(C,op);
141 }
142
143
144 void NODE_OT_select(wmOperatorType *ot)
145 {
146         /* identifiers */
147         ot->name= "Select";
148         ot->idname= "NODE_OT_select";
149         
150         /* api callbacks */
151         ot->invoke= node_select_invoke;
152         ot->poll= ED_operator_node_active;
153         
154         /* flags */
155         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
156         
157         /* properties */
158         RNA_def_int(ot->srna, "mouse_x", 0, INT_MIN, INT_MAX, "Mouse X", "", INT_MIN, INT_MAX);
159         RNA_def_int(ot->srna, "mouse_y", 0, INT_MIN, INT_MAX, "Mouse Y", "", INT_MIN, INT_MAX);
160         RNA_def_boolean(ot->srna, "extend", 0, "Extend", "");
161 }
162
163 /* ****** Border Select ****** */
164
165 static int node_borderselect_exec(bContext *C, wmOperator *op)
166 {
167         SpaceNode *snode= CTX_wm_space_node(C);
168         ARegion *ar= CTX_wm_region(C);
169         bNode *node;
170         rcti rect;
171         rctf rectf;
172         int gesture_mode= RNA_int_get(op->ptr, "gesture_mode");
173         
174         rect.xmin= RNA_int_get(op->ptr, "xmin");
175         rect.ymin= RNA_int_get(op->ptr, "ymin");
176         UI_view2d_region_to_view(&ar->v2d, rect.xmin, rect.ymin, &rectf.xmin, &rectf.ymin);
177         
178         rect.xmax= RNA_int_get(op->ptr, "xmax");
179         rect.ymax= RNA_int_get(op->ptr, "ymax");
180         UI_view2d_region_to_view(&ar->v2d, rect.xmax, rect.ymax, &rectf.xmax, &rectf.ymax);
181         
182         for(node= snode->edittree->nodes.first; node; node= node->next) {
183                 if(BLI_isect_rctf(&rectf, &node->totr, NULL)) {
184                         if(gesture_mode==GESTURE_MODAL_SELECT)
185                                 node->flag |= SELECT;
186                         else
187                                 node->flag &= ~SELECT;
188                 }
189         }
190         
191         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
192
193         return OPERATOR_FINISHED;
194 }
195
196 static int node_border_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
197 {
198         int tweak = RNA_boolean_get(op->ptr, "tweak");
199         
200         if (tweak) {
201                 /* prevent initiating the border select if the mouse is over a node */
202                 /* this allows border select on empty space, but drag-translate on nodes */
203                 SpaceNode *snode= CTX_wm_space_node(C);
204                 ARegion *ar= CTX_wm_region(C);
205                 short mval[2];
206                 float mx, my;
207                 
208                 mval[0]= event->x - ar->winrct.xmin;
209                 mval[1]= event->y - ar->winrct.ymin;
210                 
211                 /* get mouse coordinates in view2d space */
212                 mx= (float)mval[0];
213                 my= (float)mval[1];
214                 
215                 UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &mx, &my);
216                 
217                 if (node_under_mouse(snode->edittree, mx, my))
218                         return OPERATOR_CANCELLED|OPERATOR_PASS_THROUGH;
219         }
220         
221         return WM_border_select_invoke(C, op, event);
222 }
223
224 void NODE_OT_select_border(wmOperatorType *ot)
225 {
226         /* identifiers */
227         ot->name= "Border Select";
228         ot->idname= "NODE_OT_select_border";
229         
230         /* api callbacks */
231         ot->invoke= node_border_select_invoke;
232         ot->exec= node_borderselect_exec;
233         ot->modal= WM_border_select_modal;
234         
235         ot->poll= ED_operator_node_active;
236         
237         /* flags */
238         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
239         
240         /* rna */
241         WM_operator_properties_gesture_border(ot, FALSE);
242         RNA_def_boolean(ot->srna, "tweak", 0, "Tweak", "Only activate when mouse is not over a node - useful for tweak gesture");
243 }
244
245 /* ****** Select/Deselect All ****** */
246
247 static int node_select_all_exec(bContext *C, wmOperator *op)
248 {
249         SpaceNode *snode = CTX_wm_space_node(C);
250         bNode *first = snode->edittree->nodes.first;
251         bNode *node;
252         int count= 0;
253
254         for(node=first; node; node=node->next)
255                 if(node->flag & NODE_SELECT)
256                         count++;
257
258         if(count) {
259                 for(node=first; node; node=node->next)
260                         node->flag &= ~NODE_SELECT;
261         }
262         else {
263                 for(node=first; node; node=node->next)
264                         node->flag |= NODE_SELECT;
265         }
266         
267         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
268         return OPERATOR_FINISHED;
269 }
270
271 void NODE_OT_select_all(wmOperatorType *ot)
272 {
273         /* identifiers */
274         ot->name = "Select/Deselect All";
275         ot->description = "(De)select all nodes";
276         ot->idname = "NODE_OT_select_all";
277         
278         /* api callbacks */
279         ot->exec = node_select_all_exec;
280         ot->poll = ED_operator_node_active;
281         
282         /* flags */
283         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
284 }
285
286 /* ****** Select Linked To ****** */
287
288 static int node_select_linked_to_exec(bContext *C, wmOperator *op)
289 {
290         SpaceNode *snode = CTX_wm_space_node(C);
291         bNodeLink *link;
292         bNode *node;
293         
294         for (node=snode->edittree->nodes.first; node; node=node->next)
295                 node->flag &= ~NODE_TEST;
296
297         for (link=snode->edittree->links.first; link; link=link->next) {
298                 if (link->fromnode->flag & NODE_SELECT)
299                         link->tonode->flag |= NODE_TEST;
300         }
301         
302         for (node=snode->edittree->nodes.first; node; node=node->next) {
303                 if (node->flag & NODE_TEST)
304                         node->flag |= NODE_SELECT;
305         }
306         
307         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
308         return OPERATOR_FINISHED;
309 }
310
311 void NODE_OT_select_linked_to(wmOperatorType *ot)
312 {
313         /* identifiers */
314         ot->name = "Select Linked To";
315         ot->description = "Select nodes linked to the selected ones";
316         ot->idname = "NODE_OT_select_linked_to";
317         
318         /* api callbacks */
319         ot->exec = node_select_linked_to_exec;
320         ot->poll = ED_operator_node_active;
321         
322         /* flags */
323         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
324 }
325
326 /* ****** Select Linked From ****** */
327
328 static int node_select_linked_from_exec(bContext *C, wmOperator *op)
329 {
330         SpaceNode *snode = CTX_wm_space_node(C);
331         bNodeLink *link;
332         bNode *node;
333         
334         for(node=snode->edittree->nodes.first; node; node=node->next)
335                 node->flag &= ~NODE_TEST;
336
337         for(link=snode->edittree->links.first; link; link=link->next) {
338                 if(link->tonode->flag & NODE_SELECT)
339                         link->fromnode->flag |= NODE_TEST;
340         }
341         
342         for(node=snode->edittree->nodes.first; node; node=node->next) {
343                 if(node->flag & NODE_TEST)
344                         node->flag |= NODE_SELECT;
345         }
346         
347         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
348         return OPERATOR_FINISHED;
349 }
350
351 void NODE_OT_select_linked_from(wmOperatorType *ot)
352 {
353         /* identifiers */
354         ot->name = "Select Linked From";
355         ot->description = "Select nodes linked from the selected ones";
356         ot->idname = "NODE_OT_select_linked_from";
357         
358         /* api callbacks */
359         ot->exec = node_select_linked_from_exec;
360         ot->poll = ED_operator_node_active;
361         
362         /* flags */
363         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
364 }
365
366 /* ****** Select Same Type ****** */
367
368 static int node_select_same_type_exec(bContext *C, wmOperator *op)
369 {
370         SpaceNode *snode = CTX_wm_space_node(C);
371
372         node_select_same_type(snode);
373         WM_event_add_notifier(C, NC_NODE|ND_NODE_SELECT, NULL);
374         return OPERATOR_FINISHED;
375 }
376
377 void NODE_OT_select_same_type(wmOperatorType *ot)
378 {
379         /* identifiers */
380         ot->name = "Select Same Type";
381         ot->description = "Select all the same type";
382         ot->idname = "NODE_OT_select_same_type";
383         
384         /* api callbacks */
385         ot->exec = node_select_same_type_exec;
386         ot->poll = ED_operator_node_active;
387         
388         /* flags */
389         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
390 }