patch [#26978] Minor Spelling Mistakes in Editor Operators
[blender.git] / source / blender / editors / space_logic / logic_ops.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) 2009 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /** \file blender/editors/space_logic/logic_ops.c
30  *  \ingroup splogic
31  */
32
33 #include <stddef.h>
34
35 #include "DNA_object_types.h"
36 #include "DNA_sensor_types.h"
37 #include "DNA_controller_types.h"
38 #include "DNA_actuator_types.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_utildefines.h"
42
43 #include "BKE_context.h"
44 #include "BKE_main.h"
45 #include "BKE_sca.h"
46
47 #include "ED_logic.h"
48 #include "ED_object.h"
49 #include "ED_screen.h"
50
51 #include "RNA_access.h"
52 #include "RNA_define.h"
53 #include "RNA_enum_types.h"
54
55 #include "WM_api.h"
56 #include "WM_types.h"
57
58 #include "logic_intern.h"
59
60 /* ************* Generic Operator Helpers ************* */
61 static int edit_sensor_poll(bContext *C)
62 {
63         PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
64
65         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
66         return 1;
67 }
68
69 static int edit_controller_poll(bContext *C)
70 {
71         PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
72
73         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
74         return 1;
75 }
76
77 static int edit_actuator_poll(bContext *C)
78 {
79         PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
80
81         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
82         return 1;
83 }
84
85 static void edit_sensor_properties(wmOperatorType *ot)
86 {
87         RNA_def_string(ot->srna, "sensor", "", 32, "Sensor", "Name of the sensor to edit");
88         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the sensor belongs to");
89 }
90
91 static int edit_sensor_invoke_properties(bContext *C, wmOperator *op)
92 {
93         PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
94         
95         if (RNA_property_is_set(op->ptr, "sensor") && RNA_property_is_set(op->ptr, "object") )
96                 return 1;
97         
98         if (ptr.data) {
99                 bSensor *sens = ptr.data;
100                 Object *ob = ptr.id.data;
101                 
102                 RNA_string_set(op->ptr, "sensor", sens->name);
103                 RNA_string_set(op->ptr, "object", ob->id.name+2);
104                 return 1;
105         }
106         
107         return 0;
108 }
109
110 static Object *edit_object_property_get(bContext *C, wmOperator *op)
111 {
112         char ob_name[32];
113         Object *ob;
114
115         RNA_string_get(op->ptr, "object", ob_name);
116
117         /* if ob_name is valid try to find the object with this name
118         otherwise gets the active object */
119         if (BLI_strnlen(ob_name, 32) > 0)
120                 ob = BLI_findstring(&(CTX_data_main(C)->object), ob_name, offsetof(ID, name) + 2);
121         else
122                 ob= ED_object_active_context(C);
123
124         return ob;
125 }
126
127 static bSensor *edit_sensor_property_get(bContext *C, wmOperator *op, Object **ob)
128 {
129         char sensor_name[32];
130         bSensor *sens;
131         
132         RNA_string_get(op->ptr, "sensor", sensor_name);
133
134         *ob= edit_object_property_get(C, op);
135         if (!*ob) return NULL;
136         
137         sens = BLI_findstring(&((*ob)->sensors), sensor_name, offsetof(bSensor, name)); 
138         return sens;
139 }
140
141 static void edit_controller_properties(wmOperatorType *ot)
142 {
143         RNA_def_string(ot->srna, "controller", "", 32, "Controller", "Name of the controller to edit");
144         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the controller belongs to");
145 }
146
147 static int edit_controller_invoke_properties(bContext *C, wmOperator *op)
148 {
149         PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
150         
151         if (RNA_property_is_set(op->ptr, "controller") && RNA_property_is_set(op->ptr, "object") )
152                 return 1;
153         
154         if (ptr.data) {
155                 bController *cont = ptr.data;
156                 Object *ob = ptr.id.data;
157                 
158                 RNA_string_set(op->ptr, "controller", cont->name);
159                 RNA_string_set(op->ptr, "object", ob->id.name+2);
160                 return 1;
161         }
162         
163         return 0;
164 }
165
166 static bController *edit_controller_property_get(bContext *C, wmOperator *op, Object **ob)
167 {
168         char controller_name[32];
169         bController *cont;
170         
171         RNA_string_get(op->ptr, "controller", controller_name);
172
173         *ob= edit_object_property_get(C, op);
174         if (!*ob) return NULL;
175         
176         cont = BLI_findstring(&((*ob)->controllers), controller_name, offsetof(bController, name));     
177         return cont;
178 }
179
180 static void edit_actuator_properties(wmOperatorType *ot)
181 {
182         RNA_def_string(ot->srna, "actuator", "", 32, "Actuator", "Name of the actuator to edit");
183         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the actuator belongs to");
184 }
185
186 static int edit_actuator_invoke_properties(bContext *C, wmOperator *op)
187 {
188         PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
189         
190         if (RNA_property_is_set(op->ptr, "actuator") && RNA_property_is_set(op->ptr, "object") )
191                 return 1;
192         
193         if (ptr.data) {
194                 bActuator *act = ptr.data;
195                 Object *ob = ptr.id.data;
196                 
197                 RNA_string_set(op->ptr, "actuator",act->name);
198                 RNA_string_set(op->ptr, "object", ob->id.name+2);
199                 return 1;
200         }
201         
202         return 0;
203 }
204
205 static bActuator *edit_actuator_property_get(bContext *C, wmOperator *op, Object **ob)
206 {
207         char actuator_name[32];
208         bActuator *act;
209         
210         RNA_string_get(op->ptr, "actuator", actuator_name);
211
212         *ob= edit_object_property_get(C, op);
213         if (!*ob) return NULL;
214         
215         act = BLI_findstring(&((*ob)->actuators), actuator_name, offsetof(bActuator, name));    
216         return act;
217 }
218
219 static int logicbricks_move_property_get(wmOperator *op)
220 {
221         int type = RNA_enum_get(op->ptr, "direction");
222
223         if (type == 1)
224                 return TRUE;
225         else
226                 return FALSE;
227 }
228
229 /* ************* Add/Remove Sensor Operator ************* */
230
231 static int sensor_remove_exec(bContext *C, wmOperator *op)
232 {
233         Object *ob=NULL;
234         bSensor *sens = edit_sensor_property_get(C, op, &ob);
235         
236         if (!sens)
237                 return OPERATOR_CANCELLED;
238         
239         BLI_remlink(&(ob->sensors), sens);
240         free_sensor(sens);
241         
242         WM_event_add_notifier(C, NC_LOGIC, NULL);
243         
244         return OPERATOR_FINISHED;
245 }
246
247  static int sensor_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
248 {
249         if (edit_sensor_invoke_properties(C, op))
250                 return sensor_remove_exec(C, op);
251         else
252                 return OPERATOR_CANCELLED;
253 }
254
255 static void LOGIC_OT_sensor_remove(wmOperatorType *ot)
256 {
257         ot->name= "Remove Sensor";
258         ot->description= "Remove a sensor from the active object";
259         ot->idname= "LOGIC_OT_sensor_remove";
260         
261         ot->invoke= sensor_remove_invoke;
262         ot->exec= sensor_remove_exec;
263         ot->poll= edit_sensor_poll;
264         
265         /* flags */
266         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
267         edit_sensor_properties(ot);
268 }
269
270 static int sensor_add_exec(bContext *C, wmOperator *op)
271 {
272         Object *ob;
273         bSensor *sens;
274         PointerRNA sens_ptr;
275         PropertyRNA *prop;
276         const char *sens_name;
277         char name[32];
278         int type= RNA_enum_get(op->ptr, "type");
279
280         ob= edit_object_property_get(C, op);
281         if (!ob)
282                 return OPERATOR_CANCELLED;
283
284         sens= new_sensor(type);
285         BLI_addtail(&(ob->sensors), sens);
286         
287         /* set the sensor name based on rna type enum */
288         RNA_pointer_create((ID *)ob, &RNA_Sensor, sens, &sens_ptr);
289         prop = RNA_struct_find_property(&sens_ptr, "type");
290
291         RNA_string_get(op->ptr, "name", name);
292         if(BLI_strnlen(name, 32) < 1){
293                 RNA_property_enum_name(C, &sens_ptr, prop, RNA_property_enum_get(&sens_ptr, prop), &sens_name);
294                 BLI_strncpy(sens->name, sens_name, sizeof(sens->name));
295         }
296         else
297                 BLI_strncpy(sens->name, name, sizeof(sens->name));
298
299         make_unique_prop_names(C, sens->name);
300         ob->scaflag |= OB_SHOWSENS;
301
302         WM_event_add_notifier(C, NC_LOGIC, NULL);
303         
304         return OPERATOR_FINISHED;
305 }
306
307 static void LOGIC_OT_sensor_add(wmOperatorType *ot)
308 {
309         PropertyRNA *prop;
310         
311         /* identifiers */
312         ot->name= "Add Sensor";
313         ot->description = "Add a sensor to the active object";
314         ot->idname= "LOGIC_OT_sensor_add";
315         
316         /* api callbacks */
317         ot->invoke= WM_menu_invoke;
318         ot->exec= sensor_add_exec;
319         ot->poll= ED_operator_object_active_editable;
320         
321         /* flags */
322         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
323         
324         /* properties */
325         prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, SENS_ALWAYS, "Type", "Type of sensor to add");
326         RNA_def_enum_funcs(prop, rna_Sensor_type_itemf);
327         RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Sensor to add");
328         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Sensor to");
329 }
330
331 /* ************* Add/Remove Controller Operator ************* */
332
333 static int controller_remove_exec(bContext *C, wmOperator *op)
334 {
335         Object *ob = NULL;
336         bController *cont = edit_controller_property_get(C, op, &ob);
337         
338         if (!cont)
339                 return OPERATOR_CANCELLED;
340         
341         BLI_remlink(&(ob->controllers), cont);
342         unlink_controller(cont);
343         free_controller(cont);
344         
345         WM_event_add_notifier(C, NC_LOGIC, NULL);
346         
347         return OPERATOR_FINISHED;
348 }
349
350  static int controller_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
351 {
352         if (edit_controller_invoke_properties(C, op))
353                 return controller_remove_exec(C, op);
354         else
355                 return OPERATOR_CANCELLED;
356 }
357
358 static void LOGIC_OT_controller_remove(wmOperatorType *ot)
359 {
360         ot->name= "Remove Controller";
361         ot->description= "Remove a controller from the active object";
362         ot->idname= "LOGIC_OT_controller_remove";
363         
364         ot->invoke= controller_remove_invoke;
365         ot->exec= controller_remove_exec;
366         ot->poll= edit_controller_poll;
367         
368         /* flags */
369         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
370         edit_controller_properties(ot);
371 }
372
373 static int controller_add_exec(bContext *C, wmOperator *op)
374 {
375         Object *ob;
376         bController *cont;
377         PointerRNA cont_ptr;
378         PropertyRNA *prop;
379         const char *cont_name;
380         int bit;
381         char name[32];
382         int type= RNA_enum_get(op->ptr, "type");
383
384         ob= edit_object_property_get(C, op);
385         if(!ob)
386                 return OPERATOR_CANCELLED;
387         
388         cont= new_controller(type);
389         BLI_addtail(&(ob->controllers), cont);
390         
391         /* set the controller name based on rna type enum */
392         RNA_pointer_create((ID *)ob, &RNA_Controller, cont, &cont_ptr);
393         prop = RNA_struct_find_property(&cont_ptr, "type");
394
395         RNA_string_get(op->ptr, "name", name);
396         if(BLI_strnlen(name, 32) < 1){
397                 RNA_property_enum_name(C, &cont_ptr, prop, RNA_property_enum_get(&cont_ptr, prop), &cont_name);
398                 BLI_strncpy(cont->name, cont_name, sizeof(cont->name));
399         }
400         else
401                 BLI_strncpy(cont->name, name, sizeof(cont->name));
402
403         make_unique_prop_names(C, cont->name);
404         /* set the controller state mask from the current object state.
405          A controller is always in a single state, so select the lowest bit set
406          from the object state */
407         for (bit=0; bit<OB_MAX_STATES; bit++) {
408                 if (ob->state & (1<<bit))
409                         break;
410         }
411         cont->state_mask = (1<<bit);
412         if (cont->state_mask == 0) {
413                 /* shouldn't happen, object state is never 0 */
414                 cont->state_mask = 1;
415         }
416         
417         ob->scaflag |= OB_SHOWCONT;
418         
419         WM_event_add_notifier(C, NC_LOGIC, NULL);
420         
421         return OPERATOR_FINISHED;
422 }
423
424 static void LOGIC_OT_controller_add(wmOperatorType *ot)
425 {
426         /* identifiers */
427         ot->name= "Add Controller";
428         ot->description = "Add a controller to the active object";
429         ot->idname= "LOGIC_OT_controller_add";
430         
431         /* api callbacks */
432         ot->invoke= WM_menu_invoke;
433         ot->exec= controller_add_exec;
434         ot->poll= ED_operator_object_active_editable;
435         
436         /* flags */
437         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
438         
439         /* properties */
440         RNA_def_enum(ot->srna, "type", controller_type_items, CONT_LOGIC_AND, "Type", "Type of controller to add");
441         RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Controller to add");
442         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Controller to");
443 }
444
445 /* ************* Add/Remove Actuator Operator ************* */
446
447 static int actuator_remove_exec(bContext *C, wmOperator *op)
448 {
449         Object *ob=NULL;
450         bActuator *act = edit_actuator_property_get(C, op, &ob);
451         
452         if (!act)
453                 return OPERATOR_CANCELLED;
454         
455         BLI_remlink(&(ob->actuators), act);
456         unlink_actuator(act);
457         free_actuator(act);
458         
459         WM_event_add_notifier(C, NC_LOGIC, NULL);
460         
461         return OPERATOR_FINISHED;
462 }
463
464 static int actuator_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
465 {
466         if (edit_actuator_invoke_properties(C, op))
467                 return actuator_remove_exec(C, op);
468         else
469                 return OPERATOR_CANCELLED;
470 }
471
472 static void LOGIC_OT_actuator_remove(wmOperatorType *ot)
473 {
474         ot->name= "Remove Actuator";
475         ot->description= "Remove a actuator from the active object";
476         ot->idname= "LOGIC_OT_actuator_remove";
477         
478         ot->invoke= actuator_remove_invoke;
479         ot->exec= actuator_remove_exec;
480         ot->poll= edit_actuator_poll;
481         
482         /* flags */
483         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
484         edit_actuator_properties(ot);
485 }
486
487 static int actuator_add_exec(bContext *C, wmOperator *op)
488 {
489         Object *ob;
490         bActuator *act;
491         PointerRNA act_ptr;
492         PropertyRNA *prop;
493         const char *act_name;
494         char  name[32];
495         int type= RNA_enum_get(op->ptr, "type");
496                 
497         ob= edit_object_property_get(C, op);
498         if(!ob)
499                 return OPERATOR_CANCELLED;
500
501         act= new_actuator(type);
502         BLI_addtail(&(ob->actuators), act);
503         
504         /* set the actuator name based on rna type enum */
505         RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &act_ptr);
506         prop = RNA_struct_find_property(&act_ptr, "type");
507
508         RNA_string_get(op->ptr, "name", name);
509         if (BLI_strnlen(name, 32) < 1){
510                 RNA_property_enum_name(C, &act_ptr, prop, RNA_property_enum_get(&act_ptr, prop), &act_name);
511                 BLI_strncpy(act->name, act_name, sizeof(act->name));
512         }
513         else
514                 BLI_strncpy(act->name, name, sizeof(act->name));
515
516         make_unique_prop_names(C, act->name);
517         ob->scaflag |= OB_SHOWACT;
518         
519         WM_event_add_notifier(C, NC_LOGIC, NULL);
520         
521         return OPERATOR_FINISHED;
522 }
523
524 static void LOGIC_OT_actuator_add(wmOperatorType *ot)
525 {
526         PropertyRNA *prop;
527         
528         /* identifiers */
529         ot->name= "Add Actuator";
530         ot->description = "Add a actuator to the active object";
531         ot->idname= "LOGIC_OT_actuator_add";
532         
533         /* api callbacks */
534         ot->invoke= WM_menu_invoke;
535         ot->exec= actuator_add_exec;
536         ot->poll= ED_operator_object_active_editable;
537         
538         /* flags */
539         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
540         
541         /* properties */
542         prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, CONT_LOGIC_AND, "Type", "Type of actuator to add");
543         RNA_def_enum_funcs(prop, rna_Actuator_type_itemf);
544         RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Actuator to add");
545         RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Actuator to");
546 }
547
548 /* ************* Move Logic Bricks Operator ************* */
549 static EnumPropertyItem logicbricks_move_direction[] ={
550                 {1, "UP", 0, "Move Up", ""},
551                 {2, "DOWN", 0, "Move Down", ""},
552                 {0, NULL, 0, NULL, NULL}};
553
554
555 static int sensor_move_exec(bContext *C, wmOperator *op)
556 {
557         Object *ob=NULL;
558         bSensor *sens= edit_sensor_property_get(C, op, &ob);
559         int move_up= logicbricks_move_property_get(op);
560         
561         if (!sens)
562                 return OPERATOR_CANCELLED;
563
564         sca_move_sensor(sens, ob, move_up);
565
566         WM_event_add_notifier(C, NC_LOGIC, NULL);
567         
568         return OPERATOR_FINISHED;
569 }
570
571 static int sensor_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
572 {
573         if (edit_sensor_invoke_properties(C, op)) {
574                 return sensor_move_exec(C, op);
575         }
576         else
577                 return OPERATOR_CANCELLED;
578 }
579
580 static void LOGIC_OT_sensor_move(wmOperatorType *ot)
581 {
582         /* identifiers */
583         ot->name= "Move Sensor";
584         ot->description = "Move Sensor";
585         ot->idname= "LOGIC_OT_sensor_move";
586         
587         /* api callbacks */
588         ot->invoke= sensor_move_invoke;
589         ot->exec= sensor_move_exec;
590         ot->poll= edit_sensor_poll;
591         
592         /* flags */
593         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
594         
595         /* properties */
596         edit_sensor_properties(ot);
597         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
598 }
599
600 static int controller_move_exec(bContext *C, wmOperator *op)
601 {
602         Object *ob=NULL;
603         bController *cont= edit_controller_property_get(C, op, &ob);
604         int move_up= logicbricks_move_property_get(op);
605         
606         if (!cont)
607                 return OPERATOR_CANCELLED;
608
609         sca_move_controller(cont, ob, move_up);
610
611         WM_event_add_notifier(C, NC_LOGIC, NULL);
612         
613         return OPERATOR_FINISHED;
614 }
615
616 static int controller_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
617 {
618         if (edit_controller_invoke_properties(C, op)) {
619                 return controller_move_exec(C, op);
620         }
621         else
622                 return OPERATOR_CANCELLED;
623 }
624
625 static void LOGIC_OT_controller_move(wmOperatorType *ot)
626 {
627         /* identifiers */
628         ot->name= "Move Controller";
629         ot->description = "Move Controller";
630         ot->idname= "LOGIC_OT_controller_move";
631         
632         /* api callbacks */
633         ot->invoke= controller_move_invoke;
634         ot->exec= controller_move_exec;
635         ot->poll= edit_controller_poll;
636         
637         /* flags */
638         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
639         
640         /* properties */
641         edit_controller_properties(ot);
642         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
643 }
644
645 static int actuator_move_exec(bContext *C, wmOperator *op)
646 {
647         Object *ob=NULL;
648         bActuator *act = edit_actuator_property_get(C, op, &ob);
649         int move_up= logicbricks_move_property_get(op);
650
651         if (!act)
652                 return OPERATOR_CANCELLED;
653
654         sca_move_actuator(act, ob, move_up);
655
656         WM_event_add_notifier(C, NC_LOGIC, NULL);
657         
658         return OPERATOR_FINISHED;
659 }
660
661 static int actuator_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
662 {
663         if (edit_actuator_invoke_properties(C, op)) {
664                 return actuator_move_exec(C, op);
665         }
666         else
667                 return OPERATOR_CANCELLED;
668 }
669
670 static void LOGIC_OT_actuator_move(wmOperatorType *ot)
671 {
672         /* identifiers */
673         ot->name= "Move Actuator";
674         ot->description = "Move Actuator";
675         ot->idname= "LOGIC_OT_actuator_move";
676         
677         /* api callbacks */
678         ot->invoke= actuator_move_invoke;
679         ot->exec= actuator_move_exec;
680         ot->poll= edit_actuator_poll;
681         
682         /* flags */
683         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
684         
685         /* properties */
686         edit_actuator_properties(ot);
687         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
688 }
689
690
691 void ED_operatortypes_logic(void)
692 {
693         WM_operatortype_append(LOGIC_OT_sensor_remove);
694         WM_operatortype_append(LOGIC_OT_sensor_add);
695         WM_operatortype_append(LOGIC_OT_sensor_move);
696         WM_operatortype_append(LOGIC_OT_controller_remove);
697         WM_operatortype_append(LOGIC_OT_controller_add);
698         WM_operatortype_append(LOGIC_OT_controller_move);
699         WM_operatortype_append(LOGIC_OT_actuator_remove);
700         WM_operatortype_append(LOGIC_OT_actuator_add);
701         WM_operatortype_append(LOGIC_OT_actuator_move);
702 }