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