Cleanup: use `rna_enum_` prefix for RNA enums
[blender.git] / source / blender / editors / space_logic / logic_ops.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_logic/logic_ops.c
28  *  \ingroup splogic
29  */
30
31 #include <stddef.h>
32
33 #include "DNA_object_types.h"
34 #include "DNA_sensor_types.h"
35 #include "DNA_controller_types.h"
36 #include "DNA_actuator_types.h"
37 #include "DNA_scene_types.h"
38
39 #include "BLI_blenlib.h"
40 #include "BLI_utildefines.h"
41
42 #include "BLT_translation.h"
43
44 #include "BKE_context.h"
45 #include "BKE_main.h"
46 #include "BKE_sca.h"
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 "UI_view2d.h"
60
61 #include "logic_intern.h"
62
63 /* ************* Generic Operator Helpers ************* */
64 static int edit_sensor_poll(bContext *C)
65 {
66         PointerRNA ptr = CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
67
68         if (ptr.data && ((ID *)ptr.id.data)->lib) return 0;
69         return 1;
70 }
71
72 static int edit_controller_poll(bContext *C)
73 {
74         PointerRNA ptr = CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
75
76         if (ptr.data && ((ID *)ptr.id.data)->lib) return 0;
77         return 1;
78 }
79
80 static int edit_actuator_poll(bContext *C)
81 {
82         PointerRNA ptr = CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
83
84         if (ptr.data && ((ID *)ptr.id.data)->lib) return 0;
85         return 1;
86 }
87
88 static void edit_sensor_properties(wmOperatorType *ot)
89 {
90         RNA_def_string(ot->srna, "sensor", NULL, MAX_NAME, "Sensor", "Name of the sensor to edit");
91         RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the object the sensor belongs to");
92 }
93
94 static int edit_sensor_invoke_properties(bContext *C, wmOperator *op)
95 {
96         PointerRNA ptr = CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
97         
98         if (RNA_struct_property_is_set(op->ptr, "sensor") && RNA_struct_property_is_set(op->ptr, "object") )
99                 return 1;
100         
101         if (ptr.data) {
102                 bSensor *sens = ptr.data;
103                 Object *ob = ptr.id.data;
104                 
105                 RNA_string_set(op->ptr, "sensor", sens->name);
106                 RNA_string_set(op->ptr, "object", ob->id.name + 2);
107                 return 1;
108         }
109         
110         return 0;
111 }
112
113 static Object *edit_object_property_get(bContext *C, wmOperator *op)
114 {
115         char ob_name[MAX_NAME];
116         Object *ob;
117
118         RNA_string_get(op->ptr, "object", ob_name);
119
120         /* if ob_name is valid try to find the object with this name
121          * otherwise gets the active object */
122         if (*ob_name)
123                 ob = BLI_findstring(&(CTX_data_main(C)->object), ob_name, offsetof(ID, name) + 2);
124         else
125                 ob = ED_object_active_context(C);
126
127         return ob;
128 }
129
130 static bSensor *edit_sensor_property_get(bContext *C, wmOperator *op, Object **ob)
131 {
132         char sensor_name[MAX_NAME];
133         bSensor *sens;
134         
135         RNA_string_get(op->ptr, "sensor", sensor_name);
136
137         *ob = edit_object_property_get(C, op);
138         if (!*ob) return NULL;
139         
140         sens = BLI_findstring(&((*ob)->sensors), sensor_name, offsetof(bSensor, name));
141         return sens;
142 }
143
144 static void edit_controller_properties(wmOperatorType *ot)
145 {
146         RNA_def_string(ot->srna, "controller", NULL, MAX_NAME, "Controller", "Name of the controller to edit");
147         RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the object the controller belongs to");
148 }
149
150 static int edit_controller_invoke_properties(bContext *C, wmOperator *op)
151 {
152         PointerRNA ptr = CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
153         
154         if (RNA_struct_property_is_set(op->ptr, "controller") && RNA_struct_property_is_set(op->ptr, "object") )
155                 return 1;
156         
157         if (ptr.data) {
158                 bController *cont = ptr.data;
159                 Object *ob = ptr.id.data;
160                 
161                 RNA_string_set(op->ptr, "controller", cont->name);
162                 RNA_string_set(op->ptr, "object", ob->id.name + 2);
163                 return 1;
164         }
165         
166         return 0;
167 }
168
169 static bController *edit_controller_property_get(bContext *C, wmOperator *op, Object **ob)
170 {
171         char controller_name[MAX_NAME];
172         bController *cont;
173         
174         RNA_string_get(op->ptr, "controller", controller_name);
175
176         *ob = edit_object_property_get(C, op);
177         if (!*ob) return NULL;
178         
179         cont = BLI_findstring(&((*ob)->controllers), controller_name, offsetof(bController, name));
180         return cont;
181 }
182
183 static void edit_actuator_properties(wmOperatorType *ot)
184 {
185         RNA_def_string(ot->srna, "actuator", NULL, MAX_NAME, "Actuator", "Name of the actuator to edit");
186         RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the object the actuator belongs to");
187 }
188
189 static int edit_actuator_invoke_properties(bContext *C, wmOperator *op)
190 {
191         PointerRNA ptr = CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
192         
193         if (RNA_struct_property_is_set(op->ptr, "actuator") && RNA_struct_property_is_set(op->ptr, "object") )
194                 return 1;
195         
196         if (ptr.data) {
197                 bActuator *act = ptr.data;
198                 Object *ob = ptr.id.data;
199                 
200                 RNA_string_set(op->ptr, "actuator", act->name);
201                 RNA_string_set(op->ptr, "object", ob->id.name + 2);
202                 return 1;
203         }
204         
205         return 0;
206 }
207
208 static bActuator *edit_actuator_property_get(bContext *C, wmOperator *op, Object **ob)
209 {
210         char actuator_name[MAX_NAME];
211         bActuator *act;
212         
213         RNA_string_get(op->ptr, "actuator", actuator_name);
214
215         *ob = edit_object_property_get(C, op);
216         if (!*ob) return NULL;
217         
218         act = BLI_findstring(&((*ob)->actuators), actuator_name, offsetof(bActuator, name));
219         return act;
220 }
221
222 static int logicbricks_move_property_get(wmOperator *op)
223 {
224         int type = RNA_enum_get(op->ptr, "direction");
225
226         if (type == 1)
227                 return true;
228         else
229                 return false;
230 }
231
232 /* ************* Add/Remove Sensor Operator ************* */
233
234 static int sensor_remove_exec(bContext *C, wmOperator *op)
235 {
236         Object *ob = NULL;
237         bSensor *sens = edit_sensor_property_get(C, op, &ob);
238         
239         if (!sens)
240                 return OPERATOR_CANCELLED;
241         
242         BLI_remlink(&(ob->sensors), sens);
243         free_sensor(sens);
244         
245         WM_event_add_notifier(C, NC_LOGIC, NULL);
246         
247         return OPERATOR_FINISHED;
248 }
249
250 static int sensor_remove_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
251 {
252         if (edit_sensor_invoke_properties(C, op))
253                 return sensor_remove_exec(C, op);
254         else
255                 return OPERATOR_CANCELLED;
256 }
257
258 static void LOGIC_OT_sensor_remove(wmOperatorType *ot)
259 {
260         ot->name = "Remove Sensor";
261         ot->description = "Remove a sensor from the active object";
262         ot->idname = "LOGIC_OT_sensor_remove";
263         
264         ot->invoke = sensor_remove_invoke;
265         ot->exec = sensor_remove_exec;
266         ot->poll = edit_sensor_poll;
267         
268         /* flags */
269         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
270         edit_sensor_properties(ot);
271 }
272
273 static int sensor_add_exec(bContext *C, wmOperator *op)
274 {
275         Object *ob;
276         bSensor *sens;
277         PointerRNA sens_ptr;
278         PropertyRNA *prop;
279         const char *sens_name;
280         char name[MAX_NAME];
281         int type = RNA_enum_get(op->ptr, "type");
282
283         ob = edit_object_property_get(C, op);
284         if (!ob)
285                 return OPERATOR_CANCELLED;
286
287         sens = new_sensor(type);
288         BLI_addtail(&(ob->sensors), sens);
289         
290         /* set the sensor name based on rna type enum */
291         RNA_pointer_create((ID *)ob, &RNA_Sensor, sens, &sens_ptr);
292         prop = RNA_struct_find_property(&sens_ptr, "type");
293
294         RNA_string_get(op->ptr, "name", name);
295         if (*name) {
296                 BLI_strncpy(sens->name, name, sizeof(sens->name));
297         }
298         else {
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
303         BLI_uniquename(&ob->sensors, sens, DATA_("Sensor"), '.', offsetof(bSensor, name), sizeof(sens->name));
304         ob->scaflag |= OB_SHOWSENS;
305
306         WM_event_add_notifier(C, NC_LOGIC, NULL);
307         
308         return OPERATOR_FINISHED;
309 }
310
311 static void LOGIC_OT_sensor_add(wmOperatorType *ot)
312 {
313         PropertyRNA *prop;
314         
315         /* identifiers */
316         ot->name = "Add Sensor";
317         ot->description = "Add a sensor to the active object";
318         ot->idname = "LOGIC_OT_sensor_add";
319         
320         /* api callbacks */
321         ot->invoke = WM_menu_invoke;
322         ot->exec = sensor_add_exec;
323         ot->poll = ED_operator_object_active_editable;
324         
325         /* flags */
326         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
327         
328         /* properties */
329         ot->prop = prop = RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, SENS_ALWAYS, "Type", "Type of sensor to add");
330         RNA_def_enum_funcs(prop, rna_Sensor_type_itemf);
331         prop = RNA_def_string(ot->srna, "name", NULL, MAX_NAME, "Name", "Name of the Sensor to add");
332         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
333         prop = RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the Object to add the Sensor to");
334         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
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, const 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 | OPTYPE_INTERNAL;
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[MAX_NAME];
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 (*name) {
403                 BLI_strncpy(cont->name, name, sizeof(cont->name));
404         }
405         else {
406                 RNA_property_enum_name(C, &cont_ptr, prop, RNA_property_enum_get(&cont_ptr, prop), &cont_name);
407                 BLI_strncpy(cont->name, cont_name, sizeof(cont->name));
408         }
409
410         BLI_uniquename(&ob->controllers, cont, DATA_("Controller"), '.', offsetof(bController, name), sizeof(cont->name));
411
412         /* set the controller state mask from the current object state.
413          * A controller is always in a single state, so select the lowest bit set
414          * from the object state */
415         for (bit = 0; bit < OB_MAX_STATES; bit++) {
416                 if (ob->state & (1 << bit))
417                         break;
418         }
419         cont->state_mask = (1 << bit);
420         if (cont->state_mask == 0) {
421                 /* shouldn't happen, object state is never 0 */
422                 cont->state_mask = 1;
423         }
424         
425         ob->scaflag |= OB_SHOWCONT;
426         
427         WM_event_add_notifier(C, NC_LOGIC, NULL);
428         
429         return OPERATOR_FINISHED;
430 }
431
432 static void LOGIC_OT_controller_add(wmOperatorType *ot)
433 {
434         PropertyRNA *prop;
435
436         /* identifiers */
437         ot->name = "Add Controller";
438         ot->description = "Add a controller to the active object";
439         ot->idname = "LOGIC_OT_controller_add";
440         
441         /* api callbacks */
442         ot->invoke = WM_menu_invoke;
443         ot->exec = controller_add_exec;
444         ot->poll = ED_operator_object_active_editable;
445         
446         /* flags */
447         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
448         
449         /* properties */
450         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_controller_type_items, CONT_LOGIC_AND, "Type", "Type of controller to add");
451         prop = RNA_def_string(ot->srna, "name", NULL, MAX_NAME, "Name", "Name of the Controller to add");
452         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
453         prop = RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the Object to add the Controller to");
454         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
455 }
456
457 /* ************* Add/Remove Actuator Operator ************* */
458
459 static int actuator_remove_exec(bContext *C, wmOperator *op)
460 {
461         Object *ob = NULL;
462         bActuator *act = edit_actuator_property_get(C, op, &ob);
463         
464         if (!act)
465                 return OPERATOR_CANCELLED;
466         
467         BLI_remlink(&(ob->actuators), act);
468         unlink_actuator(act);
469         free_actuator(act);
470         
471         WM_event_add_notifier(C, NC_LOGIC, NULL);
472         
473         return OPERATOR_FINISHED;
474 }
475
476 static int actuator_remove_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
477 {
478         if (edit_actuator_invoke_properties(C, op))
479                 return actuator_remove_exec(C, op);
480         else
481                 return OPERATOR_CANCELLED;
482 }
483
484 static void LOGIC_OT_actuator_remove(wmOperatorType *ot)
485 {
486         ot->name = "Remove Actuator";
487         ot->description = "Remove an actuator from the active object";
488         ot->idname = "LOGIC_OT_actuator_remove";
489         
490         ot->invoke = actuator_remove_invoke;
491         ot->exec = actuator_remove_exec;
492         ot->poll = edit_actuator_poll;
493         
494         /* flags */
495         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
496         edit_actuator_properties(ot);
497 }
498
499 static int actuator_add_exec(bContext *C, wmOperator *op)
500 {
501         Object *ob;
502         bActuator *act;
503         PointerRNA act_ptr;
504         PropertyRNA *prop;
505         const char *act_name;
506         char name[MAX_NAME];
507         int type = RNA_enum_get(op->ptr, "type");
508                 
509         ob = edit_object_property_get(C, op);
510         if (!ob)
511                 return OPERATOR_CANCELLED;
512
513         act = new_actuator(type);
514         BLI_addtail(&(ob->actuators), act);
515         
516         /* set the actuator name based on rna type enum */
517         RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &act_ptr);
518         prop = RNA_struct_find_property(&act_ptr, "type");
519
520         RNA_string_get(op->ptr, "name", name);
521         if (*name) {
522                 BLI_strncpy(act->name, name, sizeof(act->name));
523         }
524         else {
525                 RNA_property_enum_name(C, &act_ptr, prop, RNA_property_enum_get(&act_ptr, prop), &act_name);
526                 BLI_strncpy(act->name, act_name, sizeof(act->name));
527         }
528
529         BLI_uniquename(&ob->actuators, act, DATA_("Actuator"), '.', offsetof(bActuator, name), sizeof(act->name));
530         ob->scaflag |= OB_SHOWACT;
531         
532         WM_event_add_notifier(C, NC_LOGIC, NULL);
533         
534         return OPERATOR_FINISHED;
535 }
536
537 static void LOGIC_OT_actuator_add(wmOperatorType *ot)
538 {
539         PropertyRNA *prop;
540         
541         /* identifiers */
542         ot->name = "Add Actuator";
543         ot->description = "Add an actuator to the active object";
544         ot->idname = "LOGIC_OT_actuator_add";
545         
546         /* api callbacks */
547         ot->invoke = WM_menu_invoke;
548         ot->exec = actuator_add_exec;
549         ot->poll = ED_operator_object_active_editable;
550         
551         /* flags */
552         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
553         
554         /* properties */
555         ot->prop = prop = RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, CONT_LOGIC_AND, "Type", "Type of actuator to add");
556         RNA_def_enum_funcs(prop, rna_Actuator_type_itemf);
557         prop = RNA_def_string(ot->srna, "name", NULL, MAX_NAME, "Name", "Name of the Actuator to add");
558         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
559         prop = RNA_def_string(ot->srna, "object", NULL, MAX_NAME, "Object", "Name of the Object to add the Actuator to");
560         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
561 }
562
563 /* ************* Move Logic Bricks Operator ************* */
564 static EnumPropertyItem logicbricks_move_direction[] = {
565         {1, "UP", 0, "Move Up", ""},
566         {2, "DOWN", 0, "Move Down", ""},
567         {0, NULL, 0, NULL, NULL}
568 };
569
570
571 static int sensor_move_exec(bContext *C, wmOperator *op)
572 {
573         Object *ob = NULL;
574         bSensor *sens = edit_sensor_property_get(C, op, &ob);
575         int move_up = logicbricks_move_property_get(op);
576         
577         if (!sens)
578                 return OPERATOR_CANCELLED;
579
580         sca_move_sensor(sens, ob, move_up);
581
582         WM_event_add_notifier(C, NC_LOGIC, NULL);
583         
584         return OPERATOR_FINISHED;
585 }
586
587 static int sensor_move_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
588 {
589         if (edit_sensor_invoke_properties(C, op)) {
590                 return sensor_move_exec(C, op);
591         }
592         else
593                 return OPERATOR_CANCELLED;
594 }
595
596 static void LOGIC_OT_sensor_move(wmOperatorType *ot)
597 {
598         /* identifiers */
599         ot->name = "Move Sensor";
600         ot->description = "Move Sensor";
601         ot->idname = "LOGIC_OT_sensor_move";
602         
603         /* api callbacks */
604         ot->invoke = sensor_move_invoke;
605         ot->exec = sensor_move_exec;
606         ot->poll = edit_sensor_poll;
607         
608         /* flags */
609         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
610         
611         /* properties */
612         edit_sensor_properties(ot);
613         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
614 }
615
616 static int controller_move_exec(bContext *C, wmOperator *op)
617 {
618         Object *ob = NULL;
619         bController *cont = edit_controller_property_get(C, op, &ob);
620         int move_up = logicbricks_move_property_get(op);
621         
622         if (!cont)
623                 return OPERATOR_CANCELLED;
624
625         sca_move_controller(cont, ob, move_up);
626
627         WM_event_add_notifier(C, NC_LOGIC, NULL);
628         
629         return OPERATOR_FINISHED;
630 }
631
632 static int controller_move_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
633 {
634         if (edit_controller_invoke_properties(C, op)) {
635                 return controller_move_exec(C, op);
636         }
637         else
638                 return OPERATOR_CANCELLED;
639 }
640
641 static void LOGIC_OT_controller_move(wmOperatorType *ot)
642 {
643         /* identifiers */
644         ot->name = "Move Controller";
645         ot->description = "Move Controller";
646         ot->idname = "LOGIC_OT_controller_move";
647         
648         /* api callbacks */
649         ot->invoke = controller_move_invoke;
650         ot->exec = controller_move_exec;
651         ot->poll = edit_controller_poll;
652         
653         /* flags */
654         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
655         
656         /* properties */
657         edit_controller_properties(ot);
658         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
659 }
660
661 static int actuator_move_exec(bContext *C, wmOperator *op)
662 {
663         Object *ob = NULL;
664         bActuator *act = edit_actuator_property_get(C, op, &ob);
665         int move_up = logicbricks_move_property_get(op);
666
667         if (!act)
668                 return OPERATOR_CANCELLED;
669
670         sca_move_actuator(act, ob, move_up);
671
672         WM_event_add_notifier(C, NC_LOGIC, NULL);
673         
674         return OPERATOR_FINISHED;
675 }
676
677 static int actuator_move_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
678 {
679         if (edit_actuator_invoke_properties(C, op)) {
680                 return actuator_move_exec(C, op);
681         }
682         else
683                 return OPERATOR_CANCELLED;
684 }
685
686 static void LOGIC_OT_actuator_move(wmOperatorType *ot)
687 {
688         /* identifiers */
689         ot->name = "Move Actuator";
690         ot->description = "Move Actuator";
691         ot->idname = "LOGIC_OT_actuator_move";
692         
693         /* api callbacks */
694         ot->invoke = actuator_move_invoke;
695         ot->exec = actuator_move_exec;
696         ot->poll = edit_actuator_poll;
697         
698         /* flags */
699         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
700         
701         /* properties */
702         edit_actuator_properties(ot);
703         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
704 }
705
706 /* ************************ view ********************* */
707
708 static int logic_view_all_exec(bContext *C, wmOperator *op)
709 {
710         ARegion *ar = CTX_wm_region(C);
711         rctf cur_new = ar->v2d.tot;
712         float aspect = BLI_rctf_size_y(&ar->v2d.cur) / BLI_rctf_size_x(&ar->v2d.cur);
713         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
714         
715         /* force the view2d code to zoom to width, not height */
716         cur_new.ymin = cur_new.ymax - BLI_rctf_size_x(&cur_new) * aspect;
717         
718         UI_view2d_smooth_view(C, ar, &cur_new, smooth_viewtx);
719
720         return OPERATOR_FINISHED;
721 }
722
723 static void LOGIC_OT_view_all(wmOperatorType *ot)
724 {
725         /* identifiers */
726         ot->name = "View All";
727         ot->idname = "LOGIC_OT_view_all";
728         ot->description = "Resize view so you can see all logic bricks";
729         
730         /* api callbacks */
731         ot->exec = logic_view_all_exec;
732         ot->poll = ED_operator_logic_active;
733         
734         /* flags */
735         ot->flag = 0;
736 }
737
738 /* ************************* */
739
740 void ED_operatortypes_logic(void)
741 {
742         WM_operatortype_append(LOGIC_OT_sensor_remove);
743         WM_operatortype_append(LOGIC_OT_sensor_add);
744         WM_operatortype_append(LOGIC_OT_sensor_move);
745         WM_operatortype_append(LOGIC_OT_controller_remove);
746         WM_operatortype_append(LOGIC_OT_controller_add);
747         WM_operatortype_append(LOGIC_OT_controller_move);
748         WM_operatortype_append(LOGIC_OT_actuator_remove);
749         WM_operatortype_append(LOGIC_OT_actuator_add);
750         WM_operatortype_append(LOGIC_OT_actuator_move);
751         WM_operatortype_append(LOGIC_OT_view_all);
752 }