uiLists enhacements: dragresize and better GRID layout.
[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",
149                        0, 0, 0, 0);
150         opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
151         RNA_enum_set(&opptr, "in_out", SOCK_IN);
152         
153         col = uiLayoutColumn(split, TRUE);
154         uiItemL(col, IFACE_("Outputs:"), ICON_NONE);
155         uiTemplateList(col, (bContext *)C, "NODE_UL_interface_sockets", "outputs", &ptr, "outputs", &ptr, "active_output",
156                        0, 0, 0, 0);
157         opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
158         RNA_enum_set(&opptr, "in_out", SOCK_OUT);
159         
160         col = uiLayoutColumn(row, TRUE);
161         opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_UP, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
162         RNA_enum_set(&opptr, "direction", 1);
163         opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_DOWN, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS);
164         RNA_enum_set(&opptr, "direction", 2);
165         
166         if (sock) {
167                 row = uiLayoutRow(layout, TRUE);
168                 uiItemR(row, &sockptr, "name", 0, NULL, ICON_NONE);
169                 uiItemO(row, "", ICON_X, "NODE_OT_tree_socket_remove");
170                 
171                 if (sock->typeinfo->interface_draw) {
172                         uiItemS(layout);
173                         sock->typeinfo->interface_draw((bContext *)C, layout, &sockptr);
174                 }
175         }
176 }
177
178 /* ******************* node buttons registration ************** */
179
180 void node_buttons_register(ARegionType *art)
181 {
182         PanelType *pt;
183         
184         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel node sockets");
185         strcpy(pt->idname, "NODE_PT_sockets");
186         strcpy(pt->label, N_("Sockets"));
187         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
188         pt->draw = node_sockets_panel;
189         pt->poll = node_sockets_poll;
190         pt->flag |= PNL_DEFAULT_CLOSED;
191         BLI_addtail(&art->paneltypes, pt);
192
193         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel tree interface");
194         strcpy(pt->idname, "NODE_PT_node_tree_interface");
195         strcpy(pt->label, N_("Interface"));
196         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
197         pt->draw = node_tree_interface_panel;
198         pt->poll = node_tree_interface_poll;
199         BLI_addtail(&art->paneltypes, pt);
200
201         pt = MEM_callocN(sizeof(PanelType), "spacetype node panel gpencil");
202         strcpy(pt->idname, "NODE_PT_gpencil");
203         strcpy(pt->label, N_("Grease Pencil"));
204         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
205         pt->draw_header = gpencil_panel_standard_header;
206         pt->draw = gpencil_panel_standard;
207         pt->poll = active_nodetree_poll;
208         BLI_addtail(&art->paneltypes, pt);
209 }
210
211 static int node_properties_toggle_exec(bContext *C, wmOperator *UNUSED(op))
212 {
213         ScrArea *sa = CTX_wm_area(C);
214         ARegion *ar = node_has_buttons_region(sa);
215         
216         if (ar)
217                 ED_region_toggle_hidden(C, ar);
218
219         return OPERATOR_FINISHED;
220 }
221
222 /* non-standard poll operator which doesn't care if there are any nodes */
223 static int node_properties_poll(bContext *C)
224 {
225         ScrArea *sa = CTX_wm_area(C);
226         return (sa && (sa->spacetype == SPACE_NODE));
227 }
228
229 void NODE_OT_properties(wmOperatorType *ot)
230 {
231         ot->name = "Properties";
232         ot->description = "Toggles the properties panel display";
233         ot->idname = "NODE_OT_properties";
234         
235         ot->exec = node_properties_toggle_exec;
236         ot->poll = node_properties_poll;
237         
238         /* flags */
239         ot->flag = 0;
240 }