← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

« back to all changes in this revision

Viewing changes to source/blender/editors/space_node/node_header.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-04-28 12:11:12 UTC
  • mto: (14.1.6 experimental) (1.5.1)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: package-import@ubuntu.com-20120428121112-2zi0vp8b6vejda8i
Tags: upstream-2.63
Import upstream version 2.63

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/editors/space_node/node_header.c
75
75
        bNode *node;
76
76
        
77
77
        /* get location to add node at mouse */
78
 
        for(ar=sa->regionbase.first; ar; ar=ar->next) {
79
 
                if(ar->regiontype == RGN_TYPE_WINDOW) {
 
78
        for (ar=sa->regionbase.first; ar; ar=ar->next) {
 
79
                if (ar->regiontype == RGN_TYPE_WINDOW) {
80
80
                        wmWindow *win= CTX_wm_window(C);
81
81
                        int x= win->eventstate->x - ar->winrct.xmin;
82
82
                        int y= win->eventstate->y - ar->winrct.ymin;
83
83
                        
84
 
                        if(y < 60) y+= 60;
 
84
                        if (y < 60) y+= 60;
85
85
                        UI_view2d_region_to_view(&ar->v2d, x, y, &snode->mx, &snode->my);
86
86
                }
87
87
        }
88
88
        
89
89
        /* store selection in temp test flag */
90
 
        for(node= snode->edittree->nodes.first; node; node= node->next) {
91
 
                if(node->flag & NODE_SELECT) node->flag |= NODE_TEST;
 
90
        for (node= snode->edittree->nodes.first; node; node= node->next) {
 
91
                if (node->flag & NODE_SELECT) node->flag |= NODE_TEST;
92
92
                else node->flag &= ~NODE_TEST;
93
93
        }
94
94
        
95
95
        /* node= */ node_add_node(snode, bmain, scene, ntemp, snode->mx, snode->my);
96
96
        
97
97
        /* select previous selection before autoconnect */
98
 
        for(node= snode->edittree->nodes.first; node; node= node->next) {
99
 
                if(node->flag & NODE_TEST) node->flag |= NODE_SELECT;
 
98
        for (node= snode->edittree->nodes.first; node; node= node->next) {
 
99
                if (node->flag & NODE_TEST) node->flag |= NODE_SELECT;
100
100
        }
101
101
        
102
102
        /* deselect after autoconnection */
103
 
        for(node= snode->edittree->nodes.first; node; node= node->next) {
104
 
                if(node->flag & NODE_TEST) node->flag &= ~NODE_SELECT;
 
103
        for (node= snode->edittree->nodes.first; node; node= node->next) {
 
104
                if (node->flag & NODE_TEST) node->flag &= ~NODE_SELECT;
105
105
        }
106
106
                
107
107
        snode_notify(C, snode);
110
110
 
111
111
static void do_node_add_static(bContext *C, void *UNUSED(arg), int event)
112
112
{
 
113
        Main *bmain = CTX_data_main(C);
 
114
        Scene *scene = CTX_data_scene(C);
113
115
        bNodeTemplate ntemp;
 
116
        
114
117
        ntemp.type = event;
 
118
        ntemp.main = bmain;
 
119
        ntemp.scene = scene;
 
120
        
115
121
        do_node_add(C, &ntemp);
116
122
}
117
123
 
118
124
static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
119
125
{
120
126
        SpaceNode *snode= CTX_wm_space_node(C);
 
127
        Main *bmain = CTX_data_main(C);
 
128
        Scene *scene = CTX_data_scene(C);
121
129
        bNodeTemplate ntemp;
122
130
        
123
131
        if (event>=0) {
143
151
        if (!ntemp.ngroup)
144
152
                return;
145
153
        
 
154
        ntemp.main = bmain;
 
155
        ntemp.scene = scene;
 
156
        
146
157
        do_node_add(C, &ntemp);
147
158
}
148
159
 
149
160
#if 0 /* disabled */
150
161
static void do_node_add_dynamic(bContext *C, void *UNUSED(arg), int event)
151
162
{
 
163
        Main *bmain = CTX_data_main(C);
 
164
        Scene *scene = CTX_data_scene(C);
152
165
        bNodeTemplate ntemp;
 
166
        
153
167
        ntemp.type = NODE_DYNAMIC;
 
168
        
 
169
        ntemp.main = bmain;
 
170
        ntemp.scene = scene;
 
171
        
154
172
        do_node_add(C, &ntemp);
155
173
}
156
174
#endif
177
195
        
178
196
        ntree = snode->nodetree;
179
197
        
180
 
        if(!ntree) {
 
198
        if (!ntree) {
181
199
                uiItemS(layout);
182
200
                return;
183
201
        }
184
202
 
185
 
        if(ntree->type == NTREE_SHADER) {
186
 
                if(scene_use_new_shading_nodes(scene))
 
203
        if (ntree->type == NTREE_SHADER) {
 
204
                if (scene_use_new_shading_nodes(scene))
187
205
                        compatibility= NODE_NEW_SHADING;
188
206
                else
189
207
                        compatibility= NODE_OLD_SHADING;
196
214
                
197
215
                /* XXX hack: negative numbers used for empty group types */
198
216
                if (node_tree_has_type(ntree->type, NODE_GROUP))
199
 
                        uiItemV(layout, "New Group", 0, -NODE_GROUP);
 
217
                        uiItemV(layout, IFACE_("New Group"), 0, -NODE_GROUP);
200
218
                if (node_tree_has_type(ntree->type, NODE_FORLOOP))
201
 
                        uiItemV(layout, "New For Loop", 0, -NODE_FORLOOP);
 
219
                        uiItemV(layout, IFACE_("New For Loop"), 0, -NODE_FORLOOP);
202
220
                if (node_tree_has_type(ntree->type, NODE_WHILELOOP))
203
 
                        uiItemV(layout, "New While Loop", 0, -NODE_WHILELOOP);
 
221
                        uiItemV(layout, IFACE_("New While Loop"), 0, -NODE_WHILELOOP);
204
222
                uiItemS(layout);
205
223
                
206
 
                for(ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) {
 
224
                for (ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) {
207
225
                        /* only use group trees */
208
226
                        if (ngroup->type==ntree->type && ELEM3(ngroup->nodetype, NODE_GROUP, NODE_FORLOOP, NODE_WHILELOOP)) {
209
227
                                uiItemV(layout, ngroup->id.name+2, 0, event);
221
239
                for (ntype=ntreeGetType(ntree->type)->node_types.first; ntype; ntype=ntype->next) {
222
240
                        if (ntype->nclass==nodeclass && ntype->name)
223
241
                                if (!compatibility || (ntype->compatibility & compatibility))
224
 
                                        uiItemV(layout, ntype->name, 0, ntype->type);
 
242
                                        uiItemV(layout, IFACE_(ntype->name), 0, ntype->type);
225
243
                }
226
244
        }
227
245
}
229
247
static void node_menu_add_foreach_cb(void *calldata, int nclass, const char *name)
230
248
{
231
249
        uiLayout *layout= calldata;
232
 
        uiItemMenuF(layout, name, 0, node_add_menu, SET_INT_IN_POINTER(nclass));
 
250
        uiItemMenuF(layout, IFACE_(name), 0, node_add_menu, SET_INT_IN_POINTER(nclass));
233
251
}
234
252
 
235
253
static void node_menu_add(const bContext *C, Menu *menu)
239
257
        uiLayout *layout= menu->layout;
240
258
        bNodeTreeType *ntreetype= ntreeGetType(snode->treetype);
241
259
 
242
 
        if(!snode->nodetree)
 
260
        if (!snode->nodetree)
243
261
                uiLayoutSetActive(layout, 0);
244
262
        
245
 
        if(ntreetype && ntreetype->foreach_nodeclass)
 
263
        if (ntreetype && ntreetype->foreach_nodeclass)
246
264
                ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb);
247
265
}
248
266