f95e895bef2d5eadb7c50037c808ab584fe06b99
[blender-staging.git] / source / blender / editors / space_node / node_buttons.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) 2009 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_buttons.c
28  *  \ingroup spnode
29  */
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_node_types.h"
34
35 #include "BLI_math.h"
36 #include "BLI_blenlib.h"
37
38 #include "BLF_translation.h"
39
40 #include "BKE_context.h"
41 #include "BKE_global.h"
42 #include "BKE_node.h"
43 #include "BKE_screen.h"
44
45 #include "WM_api.h"
46 #include "WM_types.h"
47
48 #include "RNA_access.h"
49
50 #include "ED_gpencil.h"
51 #include "ED_screen.h"
52
53 #include "UI_resources.h"
54
55 #include "node_intern.h"  /* own include */
56
57
58 /* ******************* node space & buttons ************** */
59
60 /* poll for active nodetree */
61 static int active_nodetree_poll(const bContext *C, PanelType *UNUSED(pt))
62 {
63         SpaceNode *snode = CTX_wm_space_node(C);
64         
65         return (snode && snode->nodetree);
66 }
67
68 static int node_sockets_poll(const bContext *C, PanelType *UNUSED(pt))
69 {
70         SpaceNode *snode = CTX_wm_space_node(C);
71         
72         return (snode && snode->nodetree && G.debug_value == 777);
73 }
74
75 static void node_sockets_panel(const bContext *C, Panel *pa)
76 {
77         SpaceNode *snode = CTX_wm_space_node(C);
78         bNodeTree *ntree = (snode) ? snode->edittree : NULL;
79         bNode *node = (ntree) ? nodeGetActive(ntree) : NULL;
80         bNodeSocket *sock;
81         uiLayout *layout = pa->layout, *split;
82         char name[UI_MAX_NAME_STR];
83         
84         if (ELEM(NULL, ntree, node))
85                 return;
86         
87         for (sock = node->inputs.first; sock; sock = sock->next) {
88                 BLI_snprintf(name, sizeof(name), "%s:", sock->name);
89
90                 split = uiLayoutSplit(layout, 0.35f, FALSE);
91                 uiItemL(split, name, ICON_NONE);
92                 uiTemplateNodeLink(split, ntree, node, sock);
93         }
94 }
95
96 static int node_tree_interface_poll(const bContext *C, PanelType *UNUSED(pt))
97 {
98         SpaceNode *snode = CTX_wm_space_node(C);
99         
100         return (snode && snode->edittree && (snode->edittree->inputs.first || snode->edittree->outputs.first));
101 }
102
103 static int node_tree_find_active_socket(bNodeTree *ntree, bNodeSocket **r_sock, int *r_in_out)
104 {
105         bNodeSocket *sock;
106         for (sock = ntree->inputs.first; sock; sock = sock->next) {
107                 if (sock->flag & SELECT) {
108                         *r_sock = sock;
109                         *r_in_out = SOCK_IN;
110                         return TRUE;
111                 }
112         }
113         for (sock = ntree->outputs.first; sock; sock = sock->next) {
114                 if (sock->flag & SELECT) {
115                         *r_sock = sock;
116                         *r_in_out = SOCK_OUT;
117                         return TRUE;
118                 }
119         }
120         
121         *r_sock = NULL;
122         *r_in_out = 0;
123         return FALSE;
124 }
125
126 static void node_tree_interface_panel(const bContext *C, Panel *pa)
127 {
128         SpaceNode *snode = CTX_wm_space_node(C);
129         bNodeTree *ntree = (snode) ? snode->edittree : NULL;
130         bNodeSocket *sock;
131         int in_out;
132         uiLayout *layout = pa->layout, *row, *split, *col;
133         PointerRNA ptr, sockptr, opptr;
134
135         if (!ntree)
136                 return;
137         
138         RNA_id_pointer_create((ID *)ntree, &ptr);
139         
140         node_tree_find_active_socket(ntree, &sock, &in_out);
141         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, sock, &sockptr);
142         
143         row = uiLayoutRow(layout, FALSE);
144         
145         split = uiLayoutRow(row, TRUE);
146         col = uiLayoutColumn(split, TRUE);
147         uiItemL(col, IFACE_("Inputs:"), ICON_NONE);
148         uiTemplateList(col, (bContext *)C, "NODE_UL_interface_sockets", "inputs", &ptr, "inputs", &ptr, "active_input", 0, 0, 0);
149         opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
150         RNA_enum_set(&opptr, "in_out", SOCK_IN);
151         
152         col = uiLayoutColumn(split, TRUE);
153         uiItemL(col, IFACE_("Outputs:"), ICON_NONE);
154         uiTemplateList(col, (bContext *)C, "NODE_UL_interface_sockets", "outputs", &ptr, "outputs", &ptr, "active_output", 0, 0, 0);
155         opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
156         RNA_enum_set(&opptr, "in_out", SOCK_OUT);
157         
158         col = uiLayoutColumn(row, TRUE);
159         opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_UP, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
160         RNA_enum_set(&opptr, "direction", 1);
161         opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_DOWN, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
162         RNA_enum_set(&opptr, "direction", 2);
163         
164         if (sock) {
165                 row = uiLayoutRow(layout, TRUE);
166                 uiItemR(row, &sockptr, "name", 0, NULL, ICON_NONE);
167                 uiItemO(row, "", ICON_X, "NODE_OT_tree_socket_remove");
168                 
169                 if (sock->typeinfo->interface_draw) {
170                         uiItemS(layout);
171                         sock->typeinfo->interface_draw((bContext *)C, layout, &sockptr);
172                 }
173         }
174 }
175
176 /* ******************* node buttons registration ************** */
177
178 void node_buttons_register(ARegionType *art)
179 {
180         PanelType *pt;
181         
182         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel node sockets");
183         strcpy(pt->idname, "NODE_PT_sockets");
184         strcpy(pt->label, N_("Sockets"));
185         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
186         pt->draw = node_sockets_panel;
187         pt->poll = node_sockets_poll;
188         pt->flag |= PNL_DEFAULT_CLOSED;
189         BLI_addtail(&art->paneltypes, pt);
190
191         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel tree interface");
192         strcpy(pt->idname, "NODE_PT_node_tree_interface");
193         strcpy(pt->label, N_("Interface"));
194         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
195         pt->draw = node_tree_interface_panel;
196         pt->poll = node_tree_interface_poll;
197         BLI_addtail(&art->paneltypes, pt);
198
199         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel gpencil");
200         strcpy(pt->idname, "NODE_PT_gpencil");
201         strcpy(pt->label, N_("Grease Pencil"));
202         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
203         pt->draw_header = gpencil_panel_standard_header;
204         pt->draw = gpencil_panel_standard;
205         pt->poll = active_nodetree_poll;
206         BLI_addtail(&art->paneltypes, pt);
207 }
208
209 static int node_properties_toggle_exec(bContext *C, wmOperator *UNUSED(op))
210 {
211         ScrArea *sa = CTX_wm_area(C);
212         ARegion *ar = node_has_buttons_region(sa);
213         
214         if (ar)
215                 ED_region_toggle_hidden(C, ar);
216
217         return OPERATOR_FINISHED;
218 }
219
220 /* non-standard poll operator which doesn't care if there are any nodes */
221 static int node_properties_poll(bContext *C)
222 {
223         ScrArea *sa = CTX_wm_area(C);
224         return (sa && (sa->spacetype == SPACE_NODE));
225 }
226
227 void NODE_OT_properties(wmOperatorType *ot)
228 {
229         ot->name = "Properties";
230         ot->description = "Toggles the properties panel display";
231         ot->idname = "NODE_OT_properties";
232         
233         ot->exec = node_properties_toggle_exec;
234         ot->poll = node_properties_poll;
235         
236         /* flags */
237         ot->flag = 0;
238 }