Merging r46111 through r46136 from trunk into soc-2011-tomato
[blender-staging.git] / source / blender / editors / object / object_group.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) Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/object/object_group.c
29  *  \ingroup edobj
30  */
31
32
33 #include <string.h>
34
35 #include "BLI_blenlib.h"
36 #include "BLI_utildefines.h"
37
38 #include "DNA_group_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_scene_types.h"
41
42 #include "BKE_context.h"
43 #include "BKE_depsgraph.h"
44 #include "BKE_group.h"
45 #include "BKE_main.h"
46 #include "BKE_report.h"
47
48 #include "ED_screen.h"
49 #include "ED_object.h"
50
51 #include "WM_api.h"
52 #include "WM_types.h"
53
54 #include "RNA_access.h"
55 #include "RNA_define.h"
56 #include "RNA_enum_types.h"
57
58 #include "object_intern.h"
59
60 /********************* 3d view operators ***********************/
61
62 static int objects_add_active_exec(bContext *C, wmOperator *op)
63 {
64         Main *bmain = CTX_data_main(C);
65         Scene *scene = CTX_data_scene(C);
66         Object *ob = OBACT;
67         Group *group;
68         int ok = 0, cycle = 0;
69         
70         if (!ob) return OPERATOR_CANCELLED;
71         
72         /* linking to same group requires its own loop so we can avoid
73          * looking up the active objects groups each time */
74
75         for (group = bmain->group.first; group; group = group->id.next) {
76                 if (object_in_group(ob, group)) {
77                         /* Assign groups to selected objects */
78                         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
79                         {
80                                 if (base->object->dup_group != group)
81                                         add_to_group(group, base->object, scene, base);
82                                 else
83                                         cycle = 1;
84                                 ok = 1;
85                         }
86                         CTX_DATA_END;
87                 }
88         }
89         
90         if (!ok) BKE_report(op->reports, RPT_ERROR, "Active Object contains no groups");
91         if (cycle)
92                 BKE_report(op->reports, RPT_WARNING, "Skipped some groups because of cycle detected");
93         
94         DAG_scene_sort(bmain, scene);
95         WM_event_add_notifier(C, NC_GROUP | NA_EDITED, NULL);
96         
97         return OPERATOR_FINISHED;
98 }
99
100 void GROUP_OT_objects_add_active(wmOperatorType *ot)
101 {
102         /* identifiers */
103         ot->name = "Add Selected To Active Group";
104         ot->description = "Add the object to an object group that contains the active object";
105         ot->idname = "GROUP_OT_objects_add_active";
106         
107         /* api callbacks */
108         ot->exec = objects_add_active_exec;     
109         ot->poll = ED_operator_objectmode;
110
111         /* flags */
112         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
113 }
114
115 static int objects_remove_active_exec(bContext *C, wmOperator *op)
116 {
117         Main *bmain = CTX_data_main(C);
118         Scene *scene = CTX_data_scene(C);
119         Object *ob = OBACT;
120         Group *group;
121         int ok = 0;
122         
123         if (!ob) return OPERATOR_CANCELLED;
124         
125         /* linking to same group requires its own loop so we can avoid
126          * looking up the active objects groups each time */
127
128         for (group = bmain->group.first; group; group = group->id.next) {
129                 if (object_in_group(ob, group)) {
130                         /* Assign groups to selected objects */
131                         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
132                         {
133                                 rem_from_group(group, base->object, scene, base);
134                                 ok = 1;
135                         }
136                         CTX_DATA_END;
137                 }
138         }
139         
140         if (!ok) BKE_report(op->reports, RPT_ERROR, "Active Object contains no groups");
141         
142         DAG_scene_sort(bmain, scene);
143         WM_event_add_notifier(C, NC_GROUP | NA_EDITED, NULL);
144         
145         return OPERATOR_FINISHED;
146 }
147
148 void GROUP_OT_objects_remove_active(wmOperatorType *ot)
149 {
150         /* identifiers */
151         ot->name = "Remove Selected From Active Group";
152         ot->description = "Remove the object from an object group that contains the active object";
153         ot->idname = "GROUP_OT_objects_remove_active";
154         
155         /* api callbacks */
156         ot->exec = objects_remove_active_exec;  
157         ot->poll = ED_operator_objectmode;
158         
159         /* flags */
160         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
161 }
162
163 static int group_objects_remove_exec(bContext *C, wmOperator *UNUSED(op))
164 {
165         Main *bmain = CTX_data_main(C);
166         Scene *scene = CTX_data_scene(C);
167         Group *group = NULL;
168
169         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
170         {
171                 group = NULL;
172                 while ((group = find_group(base->object, group)))
173                         rem_from_group(group, base->object, scene, base);
174         }
175         CTX_DATA_END;
176
177         DAG_scene_sort(bmain, scene);
178         WM_event_add_notifier(C, NC_GROUP | NA_EDITED, NULL);
179         
180         return OPERATOR_FINISHED;
181 }
182
183 void GROUP_OT_objects_remove(wmOperatorType *ot)
184 {
185         /* identifiers */
186         ot->name = "Remove From Groups";
187         ot->description = "Remove selected objects from all groups";
188         ot->idname = "GROUP_OT_objects_remove";
189         
190         /* api callbacks */
191         ot->exec = group_objects_remove_exec;   
192         ot->poll = ED_operator_objectmode;
193         
194         /* flags */
195         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
196 }
197
198 static int group_create_exec(bContext *C, wmOperator *op)
199 {
200         Main *bmain = CTX_data_main(C);
201         Scene *scene = CTX_data_scene(C);
202         Group *group = NULL;
203         char name[MAX_ID_NAME - 2]; /* id name */
204         
205         RNA_string_get(op->ptr, "name", name);
206         
207         group = add_group(name);
208                 
209         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
210         {
211                 add_to_group(group, base->object, scene, base);
212         }
213         CTX_DATA_END;
214
215         DAG_scene_sort(bmain, scene);
216         WM_event_add_notifier(C, NC_GROUP | NA_EDITED, NULL);
217         
218         return OPERATOR_FINISHED;
219 }
220
221 void GROUP_OT_create(wmOperatorType *ot)
222 {
223         /* identifiers */
224         ot->name = "Create New Group";
225         ot->description = "Create an object group from selected objects";
226         ot->idname = "GROUP_OT_create";
227         
228         /* api callbacks */
229         ot->exec = group_create_exec;   
230         ot->poll = ED_operator_objectmode;
231         
232         /* flags */
233         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
234         
235         RNA_def_string(ot->srna, "name", "Group", MAX_ID_NAME - 2, "Name", "Name of the new group");
236 }
237
238 /****************** properties window operators *********************/
239
240 static int group_add_exec(bContext *C, wmOperator *UNUSED(op))
241 {
242         Scene *scene = CTX_data_scene(C);
243         Object *ob = ED_object_context(C);
244         Group *group;
245
246         if (ob == NULL)
247                 return OPERATOR_CANCELLED;
248
249         group = add_group("Group");
250         add_to_group(group, ob, scene, NULL);
251
252         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
253
254         return OPERATOR_FINISHED;
255 }
256
257 void OBJECT_OT_group_add(wmOperatorType *ot)
258 {
259         /* identifiers */
260         ot->name = "Add to Group";
261         ot->idname = "OBJECT_OT_group_add";
262         ot->description = "Add an object to a new group";
263         
264         /* api callbacks */
265         ot->exec = group_add_exec;
266
267         /* flags */
268         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
269 }
270
271 static int group_link_exec(bContext *C, wmOperator *op)
272 {
273         Scene *scene = CTX_data_scene(C);
274         Object *ob = ED_object_context(C);
275         Group *group = BLI_findlink(&CTX_data_main(C)->group, RNA_enum_get(op->ptr, "group"));
276
277         if (ELEM(NULL, ob, group))
278                 return OPERATOR_CANCELLED;
279
280         add_to_group(group, ob, scene, NULL);
281
282         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
283
284         return OPERATOR_FINISHED;
285 }
286
287 void OBJECT_OT_group_link(wmOperatorType *ot)
288 {
289         PropertyRNA *prop;
290
291         /* identifiers */
292         ot->name = "Link to Group";
293         ot->idname = "OBJECT_OT_group_link";
294         ot->description = "Add an object to an existing group";
295         
296         /* api callbacks */
297         ot->exec = group_link_exec;
298         ot->invoke = WM_enum_search_invoke;
299
300         /* flags */
301         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
302
303         /* properties */
304         prop = RNA_def_enum(ot->srna, "group", DummyRNA_NULL_items, 0, "Group", "");
305         RNA_def_enum_funcs(prop, RNA_group_local_itemf);
306         ot->prop = prop;
307 }
308
309 static int group_remove_exec(bContext *C, wmOperator *UNUSED(op))
310 {
311         Scene *scene = CTX_data_scene(C);
312         Object *ob = ED_object_context(C);
313         Group *group = CTX_data_pointer_get_type(C, "group", &RNA_Group).data;
314
315         if (!ob || !group)
316                 return OPERATOR_CANCELLED;
317
318         rem_from_group(group, ob, scene, NULL); /* base will be used if found */
319
320         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
321         
322         return OPERATOR_FINISHED;
323 }
324
325 void OBJECT_OT_group_remove(wmOperatorType *ot)
326 {
327         /* identifiers */
328         ot->name = "Remove Group";
329         ot->idname = "OBJECT_OT_group_remove";
330         
331         /* api callbacks */
332         ot->exec = group_remove_exec;
333
334         /* flags */
335         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
336 }
337