1 /*************************************************************************/
2 /* canvas_item_editor_plugin.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30 #include "canvas_item_editor_plugin.h"
31 #include "editor/animation_editor.h"
32 #include "editor/editor_node.h"
33 #include "editor/editor_settings.h"
34 #include "editor/plugins/animation_player_editor_plugin.h"
35 #include "editor/plugins/script_editor_plugin.h"
36 #include "editor/script_editor_debugger.h"
37 #include "globals.h"
38 #include "os/input.h"
39 #include "os/keyboard.h"
40 #include "print_string.h"
41 #include "scene/2d/light_2d.h"
42 #include "scene/2d/particles_2d.h"
43 #include "scene/2d/polygon_2d.h"
44 #include "scene/2d/screen_button.h"
45 #include "scene/2d/sprite.h"
46 #include "scene/gui/grid_container.h"
47 #include "scene/gui/patch_9_frame.h"
48 #include "scene/main/canvas_layer.h"
49 #include "scene/main/viewport.h"
50 #include "scene/resources/packed_scene.h"
51
52 #define MIN_ZOOM 0.01
53 #define MAX_ZOOM 100
54
55 class SnapDialog : public ConfirmationDialog {
56
57 OBJ_TYPE(SnapDialog, ConfirmationDialog);
58
59 friend class CanvasItemEditor;
60
61 SpinBox *grid_offset_x;
62 SpinBox *grid_offset_y;
63 SpinBox *grid_step_x;
64 SpinBox *grid_step_y;
65 SpinBox *rotation_offset;
66 SpinBox *rotation_step;
67
68 public:
SnapDialog()69 SnapDialog() :
70 ConfirmationDialog() {
71 const int SPIN_BOX_GRID_RANGE = 256;
72 const int SPIN_BOX_ROTATION_RANGE = 360;
73 Label *label;
74 VBoxContainer *container;
75 GridContainer *child_container;
76
77 set_title(TTR("Configure Snap"));
78 get_ok()->set_text(TTR("Close"));
79
80 container = memnew(VBoxContainer);
81 add_child(container);
82 set_child_rect(container);
83
84 child_container = memnew(GridContainer);
85 child_container->set_columns(3);
86 container->add_child(child_container);
87
88 label = memnew(Label);
89 label->set_text(TTR("Grid Offset:"));
90 child_container->add_child(label);
91 label->set_h_size_flags(SIZE_EXPAND_FILL);
92
93 grid_offset_x = memnew(SpinBox);
94 grid_offset_x->set_min(-SPIN_BOX_GRID_RANGE);
95 grid_offset_x->set_max(SPIN_BOX_GRID_RANGE);
96 grid_offset_x->set_suffix("px");
97 child_container->add_child(grid_offset_x);
98
99 grid_offset_y = memnew(SpinBox);
100 grid_offset_y->set_min(-SPIN_BOX_GRID_RANGE);
101 grid_offset_y->set_max(SPIN_BOX_GRID_RANGE);
102 grid_offset_y->set_suffix("px");
103 child_container->add_child(grid_offset_y);
104
105 label = memnew(Label);
106 label->set_text(TTR("Grid Step:"));
107 child_container->add_child(label);
108 label->set_h_size_flags(SIZE_EXPAND_FILL);
109
110 grid_step_x = memnew(SpinBox);
111 grid_step_x->set_min(-SPIN_BOX_GRID_RANGE);
112 grid_step_x->set_max(SPIN_BOX_GRID_RANGE);
113 grid_step_x->set_suffix("px");
114 child_container->add_child(grid_step_x);
115
116 grid_step_y = memnew(SpinBox);
117 grid_step_y->set_min(-SPIN_BOX_GRID_RANGE);
118 grid_step_y->set_max(SPIN_BOX_GRID_RANGE);
119 grid_step_y->set_suffix("px");
120 child_container->add_child(grid_step_y);
121
122 container->add_child(memnew(HSeparator));
123
124 child_container = memnew(GridContainer);
125 child_container->set_columns(2);
126 container->add_child(child_container);
127
128 label = memnew(Label);
129 label->set_text(TTR("Rotation Offset:"));
130 child_container->add_child(label);
131 label->set_h_size_flags(SIZE_EXPAND_FILL);
132
133 rotation_offset = memnew(SpinBox);
134 rotation_offset->set_min(-SPIN_BOX_ROTATION_RANGE);
135 rotation_offset->set_max(SPIN_BOX_ROTATION_RANGE);
136 rotation_offset->set_suffix("deg");
137 child_container->add_child(rotation_offset);
138
139 label = memnew(Label);
140 label->set_text(TTR("Rotation Step:"));
141 child_container->add_child(label);
142 label->set_h_size_flags(SIZE_EXPAND_FILL);
143
144 rotation_step = memnew(SpinBox);
145 rotation_step->set_min(-SPIN_BOX_ROTATION_RANGE);
146 rotation_step->set_max(SPIN_BOX_ROTATION_RANGE);
147 rotation_step->set_suffix("deg");
148 child_container->add_child(rotation_step);
149 }
150
set_fields(const Point2 p_grid_offset,const Size2 p_grid_step,const float p_rotation_offset,const float p_rotation_step)151 void set_fields(const Point2 p_grid_offset, const Size2 p_grid_step, const float p_rotation_offset, const float p_rotation_step) {
152 grid_offset_x->set_val(p_grid_offset.x);
153 grid_offset_y->set_val(p_grid_offset.y);
154 grid_step_x->set_val(p_grid_step.x);
155 grid_step_y->set_val(p_grid_step.y);
156 rotation_offset->set_val(p_rotation_offset * (180 / Math_PI));
157 rotation_step->set_val(p_rotation_step * (180 / Math_PI));
158 }
159
get_fields(Point2 & p_grid_offset,Size2 & p_grid_step,float & p_rotation_offset,float & p_rotation_step)160 void get_fields(Point2 &p_grid_offset, Size2 &p_grid_step, float &p_rotation_offset, float &p_rotation_step) {
161 p_grid_offset.x = grid_offset_x->get_val();
162 p_grid_offset.y = grid_offset_y->get_val();
163 p_grid_step.x = grid_step_x->get_val();
164 p_grid_step.y = grid_step_y->get_val();
165 p_rotation_offset = rotation_offset->get_val() / (180 / Math_PI);
166 p_rotation_step = rotation_step->get_val() / (180 / Math_PI);
167 }
168 };
169
_edit_set_pivot(const Vector2 & mouse_pos)170 void CanvasItemEditor::_edit_set_pivot(const Vector2 &mouse_pos) {
171 List<Node *> &selection = editor_selection->get_selected_node_list();
172
173 undo_redo->create_action(TTR("Move Pivot"));
174
175 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
176
177 Node2D *n2d = E->get()->cast_to<Node2D>();
178
179 if (n2d && n2d->edit_has_pivot()) {
180
181 Vector2 offset = n2d->edit_get_pivot();
182 Vector2 gpos = n2d->get_global_pos();
183
184 Vector2 local_mouse_pos = n2d->get_canvas_transform().affine_inverse().xform(mouse_pos);
185
186 Vector2 motion_ofs = gpos - local_mouse_pos;
187
188 undo_redo->add_do_method(n2d, "set_global_pos", local_mouse_pos);
189 undo_redo->add_do_method(n2d, "edit_set_pivot", offset + n2d->get_global_transform().affine_inverse().basis_xform(motion_ofs));
190 undo_redo->add_undo_method(n2d, "set_global_pos", gpos);
191 undo_redo->add_undo_method(n2d, "edit_set_pivot", offset);
192 for (int i = 0; i < n2d->get_child_count(); i++) {
193 Node2D *n2dc = n2d->get_child(i)->cast_to<Node2D>();
194 if (!n2dc)
195 continue;
196
197 undo_redo->add_do_method(n2dc, "set_global_pos", n2dc->get_global_pos());
198 undo_redo->add_undo_method(n2dc, "set_global_pos", n2dc->get_global_pos());
199 }
200 }
201 }
202
203 undo_redo->commit_action();
204 }
205
_unhandled_key_input(const InputEvent & p_ev)206 void CanvasItemEditor::_unhandled_key_input(const InputEvent &p_ev) {
207
208 if (!is_visible() || get_viewport()->gui_has_modal_stack())
209 return;
210
211 if (p_ev.key.mod.control)
212 return;
213
214 if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode == KEY_V && drag == DRAG_NONE && can_move_pivot) {
215
216 if (p_ev.key.mod.shift) {
217 //move drag pivot
218 drag = DRAG_PIVOT;
219 } else if (!Input::get_singleton()->is_mouse_button_pressed(0)) {
220
221 List<Node *> &selection = editor_selection->get_selected_node_list();
222
223 Vector2 mouse_pos = viewport->get_local_mouse_pos();
224 if (selection.size() && viewport->get_rect().has_point(mouse_pos)) {
225 //just in case, make it work if over viewport
226 mouse_pos = transform.affine_inverse().xform(mouse_pos);
227 mouse_pos = snap_point(mouse_pos);
228
229 _edit_set_pivot(mouse_pos);
230 }
231 }
232 }
233 }
234
_tool_select(int p_index)235 void CanvasItemEditor::_tool_select(int p_index) {
236
237 ToolButton *tb[TOOL_MAX] = { select_button, list_select_button, move_button, rotate_button, pivot_button, pan_button };
238 for (int i = 0; i < TOOL_MAX; i++) {
239
240 tb[i]->set_pressed(i == p_index);
241 }
242
243 viewport->update();
244 tool = (Tool)p_index;
245 }
246
_get_editor_data(Object * p_what)247 Object *CanvasItemEditor::_get_editor_data(Object *p_what) {
248
249 CanvasItem *ci = p_what->cast_to<CanvasItem>();
250 if (!ci)
251 return NULL;
252
253 return memnew(CanvasItemEditorSelectedItem);
254 }
255
_snap_scalar(float p_offset,float p_step,bool p_snap_relative,float p_target,float p_start)256 inline float _snap_scalar(float p_offset, float p_step, bool p_snap_relative, float p_target, float p_start) {
257 float offset = p_snap_relative ? p_start : p_offset;
258 return p_step != 0 ? Math::stepify(p_target - offset, p_step) + offset : p_target;
259 }
260
snap_point(Vector2 p_target,Vector2 p_start) const261 Vector2 CanvasItemEditor::snap_point(Vector2 p_target, Vector2 p_start) const {
262 if (snap_grid) {
263 p_target.x = _snap_scalar(snap_offset.x, snap_step.x, snap_relative, p_target.x, p_start.x);
264 p_target.y = _snap_scalar(snap_offset.y, snap_step.y, snap_relative, p_target.y, p_start.y);
265 }
266 if (snap_pixel)
267 p_target = p_target.snapped(Size2(1, 1));
268
269 return p_target;
270 }
271
snap_angle(float p_target,float p_start) const272 float CanvasItemEditor::snap_angle(float p_target, float p_start) const {
273 return snap_rotation ? _snap_scalar(snap_rotation_offset, snap_rotation_step, snap_relative, p_target, p_start) : p_target;
274 }
275
get_state() const276 Dictionary CanvasItemEditor::get_state() const {
277
278 Dictionary state;
279 state["zoom"] = zoom;
280 state["ofs"] = Point2(h_scroll->get_val(), v_scroll->get_val());
281 // state["ofs"]=-transform.get_origin();
282 state["snap_offset"] = snap_offset;
283 state["snap_step"] = snap_step;
284 state["snap_rotation_offset"] = snap_rotation_offset;
285 state["snap_rotation_step"] = snap_rotation_step;
286 state["snap_grid"] = snap_grid;
287 state["snap_show_grid"] = snap_show_grid;
288 state["snap_rotation"] = snap_rotation;
289 state["snap_relative"] = snap_relative;
290 state["snap_pixel"] = snap_pixel;
291 return state;
292 }
set_state(const Dictionary & p_state)293 void CanvasItemEditor::set_state(const Dictionary &p_state) {
294
295 Dictionary state = p_state;
296 if (state.has("zoom")) {
297 zoom = p_state["zoom"];
298 }
299
300 if (state.has("ofs")) {
301 _update_scrollbars(); // i wonder how safe is calling this here..
302 Point2 ofs = p_state["ofs"];
303 h_scroll->set_val(ofs.x);
304 v_scroll->set_val(ofs.y);
305 }
306
307 if (state.has("snap_step")) {
308 snap_step = state["snap_step"];
309 }
310
311 if (state.has("snap_offset")) {
312 snap_offset = state["snap_offset"];
313 }
314
315 if (state.has("snap_rotation_step")) {
316 snap_rotation_step = state["snap_rotation_step"];
317 }
318
319 if (state.has("snap_rotation_offset")) {
320 snap_rotation_offset = state["snap_rotation_offset"];
321 }
322
323 if (state.has("snap_grid")) {
324 snap_grid = state["snap_grid"];
325 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE);
326 edit_menu->get_popup()->set_item_checked(idx, snap_grid);
327 }
328
329 if (state.has("snap_show_grid")) {
330 snap_show_grid = state["snap_show_grid"];
331 int idx = edit_menu->get_popup()->get_item_index(SNAP_SHOW_GRID);
332 edit_menu->get_popup()->set_item_checked(idx, snap_show_grid);
333 }
334
335 if (state.has("snap_rotation")) {
336 snap_rotation = state["snap_rotation"];
337 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_ROTATION);
338 edit_menu->get_popup()->set_item_checked(idx, snap_rotation);
339 }
340
341 if (state.has("snap_relative")) {
342 snap_relative = state["snap_relative"];
343 int idx = edit_menu->get_popup()->get_item_index(SNAP_RELATIVE);
344 edit_menu->get_popup()->set_item_checked(idx, snap_relative);
345 }
346
347 if (state.has("snap_pixel")) {
348 snap_pixel = state["snap_pixel"];
349 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL);
350 edit_menu->get_popup()->set_item_checked(idx, snap_pixel);
351 }
352
353 viewport->update();
354 }
355
_add_canvas_item(CanvasItem * p_canvas_item)356 void CanvasItemEditor::_add_canvas_item(CanvasItem *p_canvas_item) {
357
358 editor_selection->add_node(p_canvas_item);
359 #if 0
360 if (canvas_items.has(p_canvas_item))
361 return;
362
363 canvas_items.insert(p_canvas_item,p_info);
364 p_canvas_item->connect("hide",this,"_visibility_changed",varray(p_canvas_item->get_instance_ID()),CONNECT_ONESHOT);
365 #endif
366 }
367
_remove_canvas_item(CanvasItem * p_canvas_item)368 void CanvasItemEditor::_remove_canvas_item(CanvasItem *p_canvas_item) {
369
370 editor_selection->remove_node(p_canvas_item);
371 #if 0
372 p_canvas_item->disconnect("hide",this,"_visibility_changed");
373 canvas_items.erase(p_canvas_item);
374 #endif
375 }
_clear_canvas_items()376 void CanvasItemEditor::_clear_canvas_items() {
377
378 editor_selection->clear();
379 #if 0
380 while(canvas_items.size())
381 _remove_canvas_item(canvas_items.front()->key());
382 #endif
383 }
384
_visibility_changed(ObjectID p_canvas_item)385 void CanvasItemEditor::_visibility_changed(ObjectID p_canvas_item) {
386 #if 0
387 Object *c = ObjectDB::get_instance(p_canvas_item);
388 if (!c)
389 return;
390 CanvasItem *ct = c->cast_to<CanvasItem>();
391 if (!ct)
392 return;
393 canvas_items.erase(ct);
394 //_remove_canvas_item(ct);
395 update();
396 #endif
397 }
398
_node_removed(Node * p_node)399 void CanvasItemEditor::_node_removed(Node *p_node) {
400 #if 0
401 CanvasItem *canvas_item = (CanvasItem*)p_node; //not a good cast, but safe
402 if (canvas_items.has(canvas_item))
403 _remove_canvas_item(canvas_item);
404
405 update();
406 #endif
407 }
408
_keying_changed()409 void CanvasItemEditor::_keying_changed() {
410
411 if (AnimationPlayerEditor::singleton->get_key_editor()->is_visible())
412 animation_hb->show();
413 else
414 animation_hb->hide();
415 }
416
_is_part_of_subscene(CanvasItem * p_item)417 bool CanvasItemEditor::_is_part_of_subscene(CanvasItem *p_item) {
418
419 Node *scene_node = get_tree()->get_edited_scene_root();
420 Node *item_owner = p_item->get_owner();
421
422 return item_owner && item_owner != scene_node && p_item != scene_node && item_owner->get_filename() != "";
423 }
424
425 // slow but modern computers should have no problem
_select_canvas_item_at_pos(const Point2 & p_pos,Node * p_node,const Matrix32 & p_parent_xform,const Matrix32 & p_canvas_xform)426 CanvasItem *CanvasItemEditor::_select_canvas_item_at_pos(const Point2 &p_pos, Node *p_node, const Matrix32 &p_parent_xform, const Matrix32 &p_canvas_xform) {
427
428 if (!p_node)
429 return NULL;
430 if (p_node->cast_to<Viewport>())
431 return NULL;
432
433 CanvasItem *c = p_node->cast_to<CanvasItem>();
434
435 for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
436
437 CanvasItem *r = NULL;
438
439 if (c && !c->is_set_as_toplevel())
440 r = _select_canvas_item_at_pos(p_pos, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform);
441 else {
442 CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
443 r = _select_canvas_item_at_pos(p_pos, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform); //use base transform
444 }
445
446 if (r)
447 return r;
448 }
449
450 if (c && c->is_visible() && !c->has_meta("_edit_lock_") && !_is_part_of_subscene(c) && !c->cast_to<CanvasLayer>()) {
451
452 Rect2 rect = c->get_item_rect();
453 Point2 local_pos = (p_parent_xform * p_canvas_xform * c->get_transform()).affine_inverse().xform(p_pos);
454
455 if (rect.has_point(local_pos))
456 return c;
457 }
458
459 return NULL;
460 }
461
_find_canvas_items_at_pos(const Point2 & p_pos,Node * p_node,const Matrix32 & p_parent_xform,const Matrix32 & p_canvas_xform,Vector<_SelectResult> & r_items)462 void CanvasItemEditor::_find_canvas_items_at_pos(const Point2 &p_pos, Node *p_node, const Matrix32 &p_parent_xform, const Matrix32 &p_canvas_xform, Vector<_SelectResult> &r_items) {
463 if (!p_node)
464 return;
465 if (p_node->cast_to<Viewport>())
466 return;
467
468 CanvasItem *c = p_node->cast_to<CanvasItem>();
469
470 for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
471
472 if (c && !c->is_set_as_toplevel())
473 _find_canvas_items_at_pos(p_pos, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform, r_items);
474 else {
475 CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
476 _find_canvas_items_at_pos(p_pos, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform, r_items); //use base transform
477 }
478 }
479
480 if (c && c->is_visible() && !c->has_meta("_edit_lock_") && !c->cast_to<CanvasLayer>()) {
481
482 Rect2 rect = c->get_item_rect();
483 Point2 local_pos = (p_parent_xform * p_canvas_xform * c->get_transform()).affine_inverse().xform(p_pos);
484
485 if (rect.has_point(local_pos)) {
486 Node2D *node = c->cast_to<Node2D>();
487
488 _SelectResult res;
489 res.item = c;
490 res.z = node ? node->get_z() : 0;
491 res.has_z = node;
492 r_items.push_back(res);
493 }
494 }
495
496 return;
497 }
498
_find_canvas_items_at_rect(const Rect2 & p_rect,Node * p_node,const Matrix32 & p_parent_xform,const Matrix32 & p_canvas_xform,List<CanvasItem * > * r_items)499 void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2 &p_rect, Node *p_node, const Matrix32 &p_parent_xform, const Matrix32 &p_canvas_xform, List<CanvasItem *> *r_items) {
500
501 if (!p_node)
502 return;
503 if (p_node->cast_to<Viewport>())
504 return;
505
506 CanvasItem *c = p_node->cast_to<CanvasItem>();
507
508 bool inherited = p_node != get_tree()->get_edited_scene_root() && p_node->get_filename() != "";
509 bool editable = false;
510 if (inherited) {
511 editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(p_node);
512 }
513 bool lock_children = p_node->has_meta("_edit_group_") && p_node->get_meta("_edit_group_");
514 if (!lock_children && (!inherited || editable)) {
515 for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
516
517 if (c && !c->is_set_as_toplevel())
518 _find_canvas_items_at_rect(p_rect, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform, r_items);
519 else {
520 CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
521 _find_canvas_items_at_rect(p_rect, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform, r_items);
522 }
523 }
524 }
525
526 if (c && c->is_visible() && !c->has_meta("_edit_lock_") && !c->cast_to<CanvasLayer>()) {
527
528 Rect2 rect = c->get_item_rect();
529 Matrix32 xform = p_parent_xform * p_canvas_xform * c->get_transform();
530
531 if (p_rect.has_point(xform.xform(rect.pos)) &&
532 p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, 0))) &&
533 p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, rect.size.y))) &&
534 p_rect.has_point(xform.xform(rect.pos + Vector2(0, rect.size.y)))) {
535
536 r_items->push_back(c);
537 }
538 }
539 }
540
_select(CanvasItem * item,Point2 p_click_pos,bool p_append,bool p_drag)541 bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_append, bool p_drag) {
542
543 if (p_append) {
544 //additive selection
545
546 if (!item) {
547
548 if (p_drag) {
549 drag_from = transform.affine_inverse().xform(p_click_pos);
550
551 box_selecting = true;
552 box_selecting_to = drag_from;
553 }
554
555 return false; //nothing to add
556 }
557
558 if (editor_selection->is_selected(item)) {
559 //already in here, erase it
560 editor_selection->remove_node(item);
561 //_remove_canvas_item(c);
562
563 viewport->update();
564 return false;
565 }
566 _append_canvas_item(item);
567 viewport->update();
568
569 return true;
570
571 } else {
572 //regular selection
573
574 if (!item) {
575 //clear because nothing clicked
576 editor_selection->clear();
577
578 if (p_drag) {
579 drag_from = transform.affine_inverse().xform(p_click_pos);
580
581 box_selecting = true;
582 box_selecting_to = drag_from;
583 }
584
585 viewport->update();
586 return false;
587 }
588
589 if (!editor_selection->is_selected(item)) {
590 //select a new one and clear previous selection
591 editor_selection->clear();
592 editor_selection->add_node(item);
593 //reselect
594 if (get_tree()->is_editor_hint()) {
595 editor->call("edit_node", item);
596 }
597 }
598
599 if (p_drag) {
600 _prepare_drag(p_click_pos);
601 }
602
603 viewport->update();
604
605 return true;
606 }
607 }
608
_key_move(const Vector2 & p_dir,bool p_snap,KeyMoveMODE p_move_mode)609 void CanvasItemEditor::_key_move(const Vector2 &p_dir, bool p_snap, KeyMoveMODE p_move_mode) {
610
611 if (drag != DRAG_NONE)
612 return;
613
614 if (editor_selection->get_selected_node_list().empty())
615 return;
616
617 undo_redo->create_action(TTR("Move Action"), UndoRedo::MERGE_ENDS);
618
619 List<Node *> &selection = editor_selection->get_selected_node_list();
620
621 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
622
623 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
624 if (!canvas_item || !canvas_item->is_visible())
625 continue;
626 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
627 continue;
628
629 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
630 if (!se)
631 continue;
632
633 if (canvas_item->has_meta("_edit_lock_"))
634 continue;
635
636 Vector2 drag = p_dir;
637 if (p_snap)
638 drag *= snap_step;
639
640 undo_redo->add_undo_method(canvas_item, "edit_set_state", canvas_item->edit_get_state());
641
642 if (p_move_mode == MOVE_VIEW_BASE) {
643
644 // drag = transform.affine_inverse().basis_xform(p_dir); // zoom sensitive
645 drag = canvas_item->get_global_transform_with_canvas().affine_inverse().basis_xform(drag);
646 Rect2 local_rect = canvas_item->get_item_rect();
647 local_rect.pos += drag;
648 undo_redo->add_do_method(canvas_item, "edit_set_rect", local_rect);
649
650 } else { // p_move_mode==MOVE_LOCAL_BASE || p_move_mode==MOVE_LOCAL_WITH_ROT
651
652 if (Node2D *node_2d = canvas_item->cast_to<Node2D>()) {
653
654 if (p_move_mode == MOVE_LOCAL_WITH_ROT) {
655 Matrix32 m;
656 m.rotate(node_2d->get_rot());
657 drag = m.xform(drag);
658 }
659 node_2d->set_pos(node_2d->get_pos() + drag);
660
661 } else if (Control *control = canvas_item->cast_to<Control>()) {
662
663 control->set_pos(control->get_pos() + drag);
664 }
665 }
666 }
667
668 undo_redo->commit_action();
669 }
670
_find_topleftmost_point()671 Point2 CanvasItemEditor::_find_topleftmost_point() {
672
673 Vector2 tl = Point2(1e10, 1e10);
674 Rect2 r2;
675 r2.pos = tl;
676
677 List<Node *> &selection = editor_selection->get_selected_node_list();
678
679 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
680
681 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
682 if (!canvas_item || !canvas_item->is_visible())
683 continue;
684 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
685 continue;
686
687 Rect2 rect = canvas_item->get_item_rect();
688 Matrix32 xform = canvas_item->get_global_transform_with_canvas();
689
690 r2.expand_to(xform.xform(rect.pos));
691 r2.expand_to(xform.xform(rect.pos + Vector2(rect.size.x, 0)));
692 r2.expand_to(xform.xform(rect.pos + rect.size));
693 r2.expand_to(xform.xform(rect.pos + Vector2(0, rect.size.y)));
694 }
695
696 return r2.pos;
697 }
698
get_item_count()699 int CanvasItemEditor::get_item_count() {
700
701 List<Node *> &selection = editor_selection->get_selected_node_list();
702
703 int ic = 0;
704 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
705
706 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
707 if (!canvas_item || !canvas_item->is_visible())
708 continue;
709
710 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
711 continue;
712
713 ic++;
714 };
715
716 return ic;
717 }
718
get_single_item()719 CanvasItem *CanvasItemEditor::get_single_item() {
720
721 Map<Node *, Object *> &selection = editor_selection->get_selection();
722
723 CanvasItem *single_item = NULL;
724
725 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
726
727 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
728 if (!canvas_item || !canvas_item->is_visible())
729 continue;
730 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
731 continue;
732
733 if (single_item)
734 return NULL; //morethan one
735
736 single_item = canvas_item;
737 };
738
739 return single_item;
740 }
741
_find_drag_type(const Matrix32 & p_xform,const Rect2 & p_local_rect,const Point2 & p_click,Vector2 & r_point)742 CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Matrix32 &p_xform, const Rect2 &p_local_rect, const Point2 &p_click, Vector2 &r_point) {
743
744 CanvasItem *canvas_item = get_single_item();
745
746 ERR_FAIL_COND_V(!canvas_item, DRAG_NONE);
747
748 Rect2 rect = canvas_item->get_item_rect();
749 Matrix32 xforml = canvas_item->get_global_transform_with_canvas();
750 Matrix32 xform = transform * xforml;
751
752 Vector2 endpoints[4] = {
753
754 xform.xform(rect.pos),
755 xform.xform(rect.pos + Vector2(rect.size.x, 0)),
756 xform.xform(rect.pos + rect.size),
757 xform.xform(rect.pos + Vector2(0, rect.size.y))
758 };
759
760 Vector2 endpointsl[4] = {
761
762 xforml.xform(rect.pos),
763 xforml.xform(rect.pos + Vector2(rect.size.x, 0)),
764 xforml.xform(rect.pos + rect.size),
765 xforml.xform(rect.pos + Vector2(0, rect.size.y))
766 };
767
768 DragType dragger[] = {
769 DRAG_TOP_LEFT,
770 DRAG_TOP,
771 DRAG_TOP_RIGHT,
772 DRAG_RIGHT,
773 DRAG_BOTTOM_RIGHT,
774 DRAG_BOTTOM,
775 DRAG_BOTTOM_LEFT,
776 DRAG_LEFT
777 };
778
779 float radius = (select_handle->get_size().width / 2) * 1.5;
780
781 //try draggers
782
783 for (int i = 0; i < 4; i++) {
784
785 int prev = (i + 3) % 4;
786 int next = (i + 1) % 4;
787
788 r_point = endpointsl[i];
789
790 Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized();
791 ofs *= 1.4144 * (select_handle->get_size().width / 2);
792
793 ofs += endpoints[i];
794
795 if (ofs.distance_to(p_click) < radius)
796 return dragger[i * 2];
797
798 ofs = (endpoints[i] + endpoints[next]) / 2;
799 ofs += (endpoints[next] - endpoints[i]).tangent().normalized() * (select_handle->get_size().width / 2);
800
801 r_point = (endpointsl[i] + endpointsl[next]) / 2;
802
803 if (ofs.distance_to(p_click) < radius)
804 return dragger[i * 2 + 1];
805 }
806
807 /*
808 if (rect.has_point(xform.affine_inverse().xform(p_click))) {
809 r_point=_find_topleftmost_point();
810 return DRAG_ALL;
811 }*/
812
813 //try draggers
814
815 return DRAG_NONE;
816 }
817
_prepare_drag(const Point2 & p_click_pos)818 void CanvasItemEditor::_prepare_drag(const Point2 &p_click_pos) {
819
820 List<Node *> &selection = editor_selection->get_selected_node_list();
821
822 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
823
824 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
825 if (!canvas_item || !canvas_item->is_visible())
826 continue;
827 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
828 continue;
829
830 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
831 if (!se)
832 continue;
833
834 se->undo_state = canvas_item->edit_get_state();
835 if (canvas_item->cast_to<Node2D>())
836 se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
837 }
838
839 if (selection.size() == 1 && selection[0]->cast_to<Node2D>() && bone_ik_list.size() == 0) {
840 drag = DRAG_NODE_2D;
841 drag_point_from = selection[0]->cast_to<Node2D>()->get_global_pos();
842 } else {
843 drag = DRAG_ALL;
844 drag_point_from = _find_topleftmost_point();
845 }
846 drag_from = transform.affine_inverse().xform(p_click_pos);
847 }
848
incbeg(float & beg,float & end,float inc,float minsize,bool p_symmetric)849 void CanvasItemEditor::incbeg(float &beg, float &end, float inc, float minsize, bool p_symmetric) {
850
851 if (minsize < 0) {
852
853 beg += inc;
854 if (p_symmetric)
855 end -= inc;
856 } else {
857
858 if (p_symmetric) {
859 beg += inc;
860 end -= inc;
861 if (end - beg < minsize) {
862 float center = (beg + end) / 2.0;
863 beg = center - minsize / 2.0;
864 end = center + minsize / 2.0;
865 }
866
867 } else {
868 if (end - (beg + inc) < minsize)
869 beg = end - minsize;
870 else
871 beg += inc;
872 }
873 }
874 }
875
incend(float & beg,float & end,float inc,float minsize,bool p_symmetric)876 void CanvasItemEditor::incend(float &beg, float &end, float inc, float minsize, bool p_symmetric) {
877
878 if (minsize < 0) {
879
880 end += inc;
881 if (p_symmetric)
882 beg -= inc;
883 } else {
884
885 if (p_symmetric) {
886
887 end += inc;
888 beg -= inc;
889 if (end - beg < minsize) {
890 float center = (beg + end) / 2.0;
891 beg = center - minsize / 2.0;
892 end = center + minsize / 2.0;
893 }
894
895 } else {
896 if ((end + inc) - beg < minsize)
897 end = beg + minsize;
898 else
899 end += inc;
900 }
901 }
902 }
903
_append_canvas_item(CanvasItem * c)904 void CanvasItemEditor::_append_canvas_item(CanvasItem *c) {
905
906 editor_selection->add_node(c);
907 }
908
_snap_changed()909 void CanvasItemEditor::_snap_changed() {
910 ((SnapDialog *)snap_dialog)->get_fields(snap_offset, snap_step, snap_rotation_offset, snap_rotation_step);
911 viewport->update();
912 }
913
_dialog_value_changed(double)914 void CanvasItemEditor::_dialog_value_changed(double) {
915
916 if (updating_value_dialog)
917 return;
918
919 switch (last_option) {
920
921 case ZOOM_SET: {
922
923 zoom = dialog_val->get_val() / 100.0;
924 _update_scroll(0);
925 viewport->update();
926
927 } break;
928 default: {}
929 }
930 }
931
_selection_result_pressed(int p_result)932 void CanvasItemEditor::_selection_result_pressed(int p_result) {
933
934 if (selection_results.size() <= p_result)
935 return;
936
937 CanvasItem *item = selection_results[p_result].item;
938
939 if (item)
940 _select(item, Point2(), additive_selection, false);
941 }
942
_selection_menu_hide()943 void CanvasItemEditor::_selection_menu_hide() {
944
945 selection_results.clear();
946 selection_menu->clear();
947 selection_menu->set_size(Vector2(0, 0));
948 }
949
get_remove_list(List<Node * > * p_list)950 bool CanvasItemEditor::get_remove_list(List<Node *> *p_list) {
951
952 return false; //!p_list->empty();
953 }
954
_list_select(const InputEventMouseButton & b)955 void CanvasItemEditor::_list_select(const InputEventMouseButton &b) {
956
957 Point2 click = Point2(b.x, b.y);
958
959 Node *scene = editor->get_edited_scene();
960 if (!scene)
961 return;
962
963 _find_canvas_items_at_pos(click, scene, transform, Matrix32(), selection_results);
964
965 for (int i = 0; i < selection_results.size(); i++) {
966 CanvasItem *item = selection_results[i].item;
967 if (item != scene && item->get_owner() != scene && !scene->is_editable_instance(item->get_owner())) {
968 //invalid result
969 selection_results.remove(i);
970 i--;
971 }
972 }
973
974 if (selection_results.size() == 1) {
975
976 CanvasItem *item = selection_results[0].item;
977 selection_results.clear();
978
979 additive_selection = b.mod.shift;
980 if (!_select(item, click, additive_selection, false))
981 return;
982
983 } else if (!selection_results.empty()) {
984
985 selection_results.sort();
986
987 NodePath root_path = get_tree()->get_edited_scene_root()->get_path();
988 StringName root_name = root_path.get_name(root_path.get_name_count() - 1);
989
990 for (int i = 0; i < selection_results.size(); i++) {
991
992 CanvasItem *item = selection_results[i].item;
993
994 Ref<Texture> icon;
995 if (item->has_meta("_editor_icon"))
996 icon = item->get_meta("_editor_icon");
997 else
998 icon = get_icon(has_icon(item->get_type(), "EditorIcons") ? item->get_type() : String("Object"), "EditorIcons");
999
1000 String node_path = "/" + root_name + "/" + root_path.rel_path_to(item->get_path());
1001
1002 selection_menu->add_item(item->get_name());
1003 selection_menu->set_item_icon(i, icon);
1004 selection_menu->set_item_metadata(i, node_path);
1005 selection_menu->set_item_tooltip(i, String(item->get_name()) +
1006 "\nType: " + item->get_type() + "\nPath: " + node_path);
1007 }
1008
1009 additive_selection = b.mod.shift;
1010
1011 selection_menu->set_global_pos(Vector2(b.global_x, b.global_y));
1012 selection_menu->popup();
1013 selection_menu->call_deferred("grab_click_focus");
1014 selection_menu->set_invalidate_click_until_motion();
1015
1016 return;
1017 }
1018 }
1019
_viewport_input_event(const InputEvent & p_event)1020 void CanvasItemEditor::_viewport_input_event(const InputEvent &p_event) {
1021
1022 {
1023
1024 EditorNode *en = editor;
1025 EditorPluginList *over_plugin_list = en->get_editor_plugins_over();
1026
1027 if (!over_plugin_list->empty()) {
1028 bool discard = over_plugin_list->forward_input_event(p_event);
1029 if (discard) {
1030 accept_event();
1031 return;
1032 }
1033 }
1034 }
1035
1036 if (p_event.type == InputEvent::MOUSE_BUTTON) {
1037
1038 const InputEventMouseButton &b = p_event.mouse_button;
1039
1040 if (b.button_index == BUTTON_WHEEL_DOWN) {
1041
1042 if (bool(EditorSettings::get_singleton()->get("2d_editor/scroll_to_pan"))) {
1043
1044 v_scroll->set_val(v_scroll->get_val() + int(EditorSettings::get_singleton()->get("2d_editor/pan_speed")) / zoom * b.factor);
1045
1046 } else {
1047
1048 if (zoom < MIN_ZOOM)
1049 return;
1050
1051 float prev_zoom = zoom;
1052 zoom = zoom * (1 - (0.05 * b.factor));
1053 {
1054 Point2 ofs(b.x, b.y);
1055 ofs = ofs / prev_zoom - ofs / zoom;
1056 h_scroll->set_val(h_scroll->get_val() + ofs.x);
1057 v_scroll->set_val(v_scroll->get_val() + ofs.y);
1058 }
1059 }
1060
1061 _update_scroll(0);
1062 viewport->update();
1063 return;
1064 }
1065
1066 if (b.button_index == BUTTON_WHEEL_UP) {
1067
1068 if (bool(EditorSettings::get_singleton()->get("2d_editor/scroll_to_pan"))) {
1069
1070 v_scroll->set_val(v_scroll->get_val() - int(EditorSettings::get_singleton()->get("2d_editor/pan_speed")) / zoom * b.factor);
1071
1072 } else {
1073
1074 if (zoom > MAX_ZOOM)
1075 return;
1076
1077 float prev_zoom = zoom;
1078 zoom = zoom * ((0.95 + (0.05 * b.factor)) / 0.95);
1079 {
1080 Point2 ofs(b.x, b.y);
1081 ofs = ofs / prev_zoom - ofs / zoom;
1082 h_scroll->set_val(h_scroll->get_val() + ofs.x);
1083 v_scroll->set_val(v_scroll->get_val() + ofs.y);
1084 }
1085 }
1086
1087 _update_scroll(0);
1088 viewport->update();
1089 return;
1090 }
1091
1092 if (b.button_index == BUTTON_WHEEL_LEFT) {
1093
1094 if (bool(EditorSettings::get_singleton()->get("2d_editor/scroll_to_pan"))) {
1095
1096 h_scroll->set_val(h_scroll->get_val() - int(EditorSettings::get_singleton()->get("2d_editor/pan_speed")) / zoom * b.factor);
1097
1098 _update_scroll(0);
1099 viewport->update();
1100 }
1101 }
1102
1103 if (b.button_index == BUTTON_WHEEL_RIGHT) {
1104
1105 if (bool(EditorSettings::get_singleton()->get("2d_editor/scroll_to_pan"))) {
1106
1107 h_scroll->set_val(h_scroll->get_val() + int(EditorSettings::get_singleton()->get("2d_editor/pan_speed")) / zoom * b.factor);
1108
1109 _update_scroll(0);
1110 viewport->update();
1111 }
1112 }
1113
1114 if (b.button_index == BUTTON_RIGHT) {
1115
1116 if (b.pressed && (tool == TOOL_SELECT && b.mod.alt)) {
1117
1118 _list_select(b);
1119 return;
1120 }
1121
1122 if (get_item_count() > 0 && drag != DRAG_NONE) {
1123 //cancel drag
1124
1125 if (bone_ik_list.size()) {
1126
1127 for (List<BoneIK>::Element *E = bone_ik_list.back(); E; E = E->prev()) {
1128
1129 E->get().node->edit_set_state(E->get().orig_state);
1130 }
1131
1132 bone_ik_list.clear();
1133
1134 } else {
1135
1136 List<Node *> &selection = editor_selection->get_selected_node_list();
1137
1138 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
1139
1140 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
1141 if (!canvas_item || !canvas_item->is_visible())
1142 continue;
1143 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
1144 continue;
1145
1146 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
1147 if (!se)
1148 continue;
1149
1150 canvas_item->edit_set_state(se->undo_state);
1151 if (canvas_item->cast_to<Node2D>())
1152 canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
1153 }
1154 }
1155
1156 drag = DRAG_NONE;
1157 viewport->update();
1158 can_move_pivot = false;
1159
1160 } else if (box_selecting) {
1161 box_selecting = false;
1162 viewport->update();
1163 } else if (b.pressed) {
1164 #if 0
1165 ref_item = NULL;
1166 Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene();
1167 if ( scene ) ref_item =_select_canvas_item_at_pos( Point2( b.x, b.y ), scene, transform );
1168 #endif
1169 //popup->set_pos(Point2(b.x,b.y));
1170 //popup->popup();
1171 }
1172 return;
1173 }
1174 //if (!canvas_items.size())
1175 // return;
1176
1177 if (b.button_index == BUTTON_LEFT && tool == TOOL_LIST_SELECT) {
1178 if (b.pressed)
1179 _list_select(b);
1180 return;
1181 }
1182
1183 if (b.button_index == BUTTON_LEFT && tool == TOOL_EDIT_PIVOT) {
1184 if (b.pressed) {
1185
1186 Point2 mouse_pos(b.x, b.y);
1187 mouse_pos = transform.affine_inverse().xform(mouse_pos);
1188 mouse_pos = snap_point(mouse_pos);
1189 _edit_set_pivot(mouse_pos);
1190 }
1191 return;
1192 }
1193
1194 if (tool == TOOL_PAN || b.button_index != BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE))
1195 return;
1196
1197 if (!b.pressed) {
1198
1199 if (drag != DRAG_NONE) {
1200
1201 if (undo_redo) {
1202
1203 if (bone_ik_list.size()) {
1204
1205 undo_redo->create_action(TTR("Edit IK Chain"));
1206
1207 for (List<BoneIK>::Element *E = bone_ik_list.back(); E; E = E->prev()) {
1208
1209 undo_redo->add_do_method(E->get().node, "edit_set_state", E->get().node->edit_get_state());
1210 undo_redo->add_undo_method(E->get().node, "edit_set_state", E->get().orig_state);
1211 }
1212
1213 undo_redo->add_do_method(viewport, "update");
1214 undo_redo->add_undo_method(viewport, "update");
1215
1216 bone_ik_list.clear();
1217
1218 undo_redo->commit_action();
1219 } else {
1220
1221 undo_redo->create_action(TTR("Edit CanvasItem"));
1222
1223 List<Node *> &selection = editor_selection->get_selected_node_list();
1224
1225 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
1226
1227 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
1228 if (!canvas_item || !canvas_item->is_visible())
1229 continue;
1230 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
1231 continue;
1232
1233 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
1234 if (!se)
1235 continue;
1236
1237 Variant state = canvas_item->edit_get_state();
1238 undo_redo->add_do_method(canvas_item, "edit_set_state", state);
1239 undo_redo->add_undo_method(canvas_item, "edit_set_state", se->undo_state);
1240 if (canvas_item->cast_to<Node2D>()) {
1241 Node2D *pvt = canvas_item->cast_to<Node2D>();
1242 if (pvt->edit_has_pivot()) {
1243 undo_redo->add_do_method(canvas_item, "edit_set_pivot", pvt->edit_get_pivot());
1244 undo_redo->add_undo_method(canvas_item, "edit_set_pivot", se->undo_pivot);
1245 }
1246 }
1247 }
1248 undo_redo->commit_action();
1249 }
1250 }
1251
1252 drag = DRAG_NONE;
1253 viewport->update();
1254 can_move_pivot = false;
1255 }
1256
1257 if (box_selecting) {
1258 #if 0
1259 if ( ! b.mod.shift ) _clear_canvas_items();
1260 if ( box_selection_end() ) return;
1261 #endif
1262
1263 Node *scene = editor->get_edited_scene();
1264 if (scene) {
1265
1266 List<CanvasItem *> selitems;
1267
1268 Point2 bsfrom = transform.xform(drag_from);
1269 Point2 bsto = transform.xform(box_selecting_to);
1270 if (bsfrom.x > bsto.x)
1271 SWAP(bsfrom.x, bsto.x);
1272 if (bsfrom.y > bsto.y)
1273 SWAP(bsfrom.y, bsto.y);
1274
1275 _find_canvas_items_at_rect(Rect2(bsfrom, bsto - bsfrom), scene, transform, Matrix32(), &selitems);
1276
1277 for (List<CanvasItem *>::Element *E = selitems.front(); E; E = E->next()) {
1278
1279 _append_canvas_item(E->get());
1280 }
1281 }
1282
1283 box_selecting = false;
1284 viewport->update();
1285 }
1286 return;
1287 }
1288
1289 Map<ObjectID, BoneList>::Element *Cbone = NULL; //closest
1290
1291 {
1292 bone_ik_list.clear();
1293 float closest_dist = 1e20;
1294 int bone_width = EditorSettings::get_singleton()->get("2d_editor/bone_width");
1295 for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
1296
1297 if (E->get().from == E->get().to)
1298 continue;
1299 Vector2 s[2] = {
1300 E->get().from,
1301 E->get().to
1302 };
1303
1304 Vector2 p = Geometry::get_closest_point_to_segment_2d(Vector2(b.x, b.y), s);
1305 float d = p.distance_to(Vector2(b.x, b.y));
1306 if (d < bone_width && d < closest_dist) {
1307 Cbone = E;
1308 closest_dist = d;
1309 }
1310 }
1311
1312 if (Cbone) {
1313 Node2D *b = NULL;
1314 Object *obj = ObjectDB::get_instance(Cbone->get().bone);
1315 if (obj)
1316 b = obj->cast_to<Node2D>();
1317
1318 if (b) {
1319
1320 bool ik_found = false;
1321 bool first = true;
1322
1323 while (b) {
1324
1325 CanvasItem *pi = b->get_parent_item();
1326 if (!pi)
1327 break;
1328
1329 float len = pi->get_global_transform().get_origin().distance_to(b->get_global_pos());
1330 b = pi->cast_to<Node2D>();
1331 if (!b)
1332 break;
1333
1334 if (first) {
1335
1336 bone_orig_xform = b->get_global_transform();
1337 first = false;
1338 }
1339
1340 BoneIK bik;
1341 bik.node = b;
1342 bik.len = len;
1343 bik.orig_state = b->edit_get_state();
1344
1345 bone_ik_list.push_back(bik);
1346
1347 if (b->has_meta("_edit_ik_")) {
1348
1349 ik_found = bone_ik_list.size() > 1;
1350 break;
1351 }
1352
1353 if (!pi->has_meta("_edit_bone_"))
1354 break;
1355 }
1356
1357 if (!ik_found)
1358 bone_ik_list.clear();
1359 }
1360 }
1361 }
1362
1363 CanvasItem *single_item = get_single_item();
1364
1365 if (single_item) {
1366 //try single canvas_item edit
1367
1368 CanvasItem *canvas_item = single_item;
1369 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
1370 ERR_FAIL_COND(!se);
1371
1372 Point2 click(b.x, b.y);
1373
1374 if ((b.mod.control && tool == TOOL_SELECT) || tool == TOOL_ROTATE) {
1375
1376 drag = DRAG_ROTATE;
1377 drag_from = transform.affine_inverse().xform(click);
1378 se->undo_state = canvas_item->edit_get_state();
1379 if (canvas_item->cast_to<Node2D>())
1380 se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
1381 if (canvas_item->cast_to<Control>())
1382 se->undo_pivot = Vector2();
1383 return;
1384 }
1385
1386 Matrix32 xform = transform * canvas_item->get_global_transform_with_canvas();
1387 Rect2 rect = canvas_item->get_item_rect();
1388 // float handle_radius = handle_len * 1.4144; //magic number, guess what it means!
1389
1390 if (tool == TOOL_SELECT) {
1391 drag = _find_drag_type(xform, rect, click, drag_point_from);
1392
1393 if (b.doubleclick) {
1394
1395 if (canvas_item->get_filename() != "" && canvas_item != editor->get_edited_scene()) {
1396
1397 editor->open_request(canvas_item->get_filename());
1398 return;
1399 }
1400 }
1401
1402 if (drag != DRAG_NONE && (!Cbone || (drag != DRAG_ALL && drag != DRAG_NODE_2D))) {
1403 drag_from = transform.affine_inverse().xform(click);
1404 se->undo_state = canvas_item->edit_get_state();
1405 if (canvas_item->cast_to<Node2D>())
1406 se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
1407
1408 return;
1409 }
1410 } else {
1411
1412 drag = DRAG_NONE;
1413 }
1414 }
1415
1416 //multi canvas_item edit
1417
1418 Point2 click = Point2(b.x, b.y);
1419
1420 if ((b.mod.alt || tool == TOOL_MOVE) && get_item_count()) {
1421
1422 _prepare_drag(click);
1423 viewport->update();
1424 return;
1425 }
1426
1427 Node *scene = editor->get_edited_scene();
1428 if (!scene)
1429 return;
1430
1431 /*
1432 if (current_window) {
1433 //no window.... ?
1434 click-=current_window->get_scroll();
1435 }*/
1436 CanvasItem *c = NULL;
1437
1438 if (Cbone) {
1439
1440 Object *obj = ObjectDB::get_instance(Cbone->get().bone);
1441 if (obj)
1442 c = obj->cast_to<CanvasItem>();
1443 if (c)
1444 c = c->get_parent_item();
1445 }
1446 if (!c) {
1447 c = _select_canvas_item_at_pos(click, scene, transform, Matrix32());
1448
1449 CanvasItem *cn = c;
1450
1451 while (cn) {
1452 if (cn->has_meta("_edit_group_")) {
1453 c = cn;
1454 }
1455 cn = cn->get_parent_item();
1456 }
1457 }
1458
1459 Node *n = c;
1460
1461 while ((n && n != scene && n->get_owner() != scene) || (n && !n->is_type("CanvasItem"))) {
1462 n = n->get_parent();
1463 };
1464
1465 if (n) {
1466 c = n->cast_to<CanvasItem>();
1467 } else {
1468 c = NULL;
1469 }
1470
1471 additive_selection = b.mod.shift;
1472 if (!_select(c, click, additive_selection))
1473 return;
1474 }
1475
1476 if (p_event.type == InputEvent::MOUSE_MOTION) {
1477
1478 if (!viewport->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field()))
1479 viewport->call_deferred("grab_focus");
1480
1481 const InputEventMouseMotion &m = p_event.mouse_motion;
1482
1483 if (box_selecting) {
1484
1485 box_selecting_to = transform.affine_inverse().xform(Point2(m.x, m.y));
1486 viewport->update();
1487 return;
1488 }
1489
1490 if (drag == DRAG_NONE) {
1491
1492 if ((m.button_mask & BUTTON_MASK_LEFT && tool == TOOL_PAN) || m.button_mask & BUTTON_MASK_MIDDLE || (m.button_mask & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) {
1493
1494 Point2i relative;
1495 if (bool(EditorSettings::get_singleton()->get("2d_editor/warped_mouse_panning"))) {
1496 relative = Input::get_singleton()->warp_mouse_motion(m, viewport->get_global_rect());
1497 } else {
1498 relative = Point2i(m.relative_x, m.relative_y);
1499 }
1500
1501 h_scroll->set_val(h_scroll->get_val() - relative.x / zoom);
1502 v_scroll->set_val(v_scroll->get_val() - relative.y / zoom);
1503 }
1504
1505 return;
1506 }
1507
1508 List<Node *> &selection = editor_selection->get_selected_node_list();
1509
1510 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
1511
1512 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
1513 if (!canvas_item || !canvas_item->is_visible())
1514 continue;
1515 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
1516 continue;
1517
1518 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
1519 if (!se)
1520 continue;
1521
1522 bool dragging_bone = drag == DRAG_ALL && selection.size() == 1 && bone_ik_list.size();
1523
1524 if (!dragging_bone) {
1525 canvas_item->edit_set_state(se->undo_state); //reset state and reapply
1526 if (canvas_item->cast_to<Node2D>())
1527 canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
1528 }
1529
1530 Vector2 dfrom = drag_from;
1531 Vector2 dto = transform.affine_inverse().xform(Point2(m.x, m.y));
1532 if (canvas_item->has_meta("_edit_lock_"))
1533 continue;
1534
1535 if (drag == DRAG_ROTATE) {
1536
1537 Vector2 center = canvas_item->get_global_transform_with_canvas().get_origin();
1538 {
1539 Node2D *node = canvas_item->cast_to<Node2D>();
1540
1541 if (node) {
1542 Matrix32 rot;
1543 rot.elements[1] = (dfrom - center).normalized();
1544 rot.elements[0] = rot.elements[1].tangent();
1545 node->set_rot(snap_angle(rot.xform_inv(dto - center).angle() + node->get_rot(), node->get_rot()));
1546 display_rotate_to = dto;
1547 display_rotate_from = center;
1548 viewport->update();
1549 }
1550 }
1551
1552 {
1553 Control *node = canvas_item->cast_to<Control>();
1554
1555 if (node) {
1556 Matrix32 rot;
1557 rot.elements[1] = (dfrom - center).normalized();
1558 rot.elements[0] = rot.elements[1].tangent();
1559 node->set_rotation(snap_angle(rot.xform_inv(dto - center).angle() + node->get_rotation(), node->get_rotation()));
1560 display_rotate_to = dto;
1561 display_rotate_from = center;
1562 viewport->update();
1563 }
1564 }
1565
1566 continue;
1567 }
1568
1569 bool uniform = m.mod.shift;
1570 bool symmetric = m.mod.alt;
1571
1572 dto = dto - (drag == DRAG_ALL || drag == DRAG_NODE_2D ? drag_from - drag_point_from : Vector2(0, 0));
1573
1574 if (uniform && (drag == DRAG_ALL || drag == DRAG_NODE_2D)) {
1575 if (ABS(dto.x - drag_point_from.x) > ABS(dto.y - drag_point_from.y)) {
1576 dto.y = drag_point_from.y;
1577 } else {
1578 dto.x = drag_point_from.x;
1579 }
1580 }
1581
1582 dfrom = drag_point_from;
1583 dto = snap_point(dto, drag_point_from);
1584
1585 Vector2 drag_vector =
1586 canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dto) -
1587 canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dfrom);
1588
1589 Rect2 local_rect = canvas_item->get_item_rect();
1590 Vector2 begin = local_rect.pos;
1591 Vector2 end = local_rect.pos + local_rect.size;
1592 Vector2 minsize = canvas_item->edit_get_minimum_size();
1593
1594 if (uniform) {
1595 float aspect = local_rect.size.get_aspect();
1596 switch (drag) {
1597 case DRAG_BOTTOM_LEFT:
1598 case DRAG_TOP_RIGHT: {
1599 if (aspect > 1.0) { // width > height, take x as reference
1600 drag_vector.y = -drag_vector.x / aspect;
1601 } else { // height > width, take y as reference
1602 drag_vector.x = -drag_vector.y * aspect;
1603 }
1604 } break;
1605 case DRAG_BOTTOM_RIGHT:
1606 case DRAG_TOP_LEFT: {
1607 if (aspect > 1.0) { // width > height, take x as reference
1608 drag_vector.y = drag_vector.x / aspect;
1609 } else { // height > width, take y as reference
1610 drag_vector.x = drag_vector.y * aspect;
1611 }
1612 } break;
1613 default: {}
1614 }
1615 }
1616
1617 switch (drag) {
1618 case DRAG_ALL: {
1619 begin += drag_vector;
1620 end += drag_vector;
1621 } break;
1622 case DRAG_RIGHT: {
1623
1624 incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1625
1626 } break;
1627 case DRAG_BOTTOM: {
1628
1629 incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1630
1631 } break;
1632 case DRAG_BOTTOM_RIGHT: {
1633
1634 incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1635 incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1636 } break;
1637 case DRAG_TOP_LEFT: {
1638
1639 incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1640 incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1641 } break;
1642 case DRAG_TOP: {
1643
1644 incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1645
1646 } break;
1647 case DRAG_LEFT: {
1648
1649 incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1650
1651 } break;
1652 case DRAG_TOP_RIGHT: {
1653
1654 incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1655 incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1656
1657 } break;
1658 case DRAG_BOTTOM_LEFT: {
1659
1660 incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
1661 incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
1662 } break;
1663 case DRAG_PIVOT: {
1664
1665 if (canvas_item->cast_to<Node2D>()) {
1666 Node2D *n2d = canvas_item->cast_to<Node2D>();
1667 n2d->edit_set_pivot(se->undo_pivot + drag_vector);
1668 }
1669 continue;
1670 } break;
1671 case DRAG_NODE_2D: {
1672
1673 ERR_FAIL_COND(!canvas_item->cast_to<Node2D>());
1674 canvas_item->cast_to<Node2D>()->set_global_pos(dto);
1675 continue;
1676 } break;
1677
1678 default: {}
1679 }
1680
1681 if (!dragging_bone) {
1682
1683 local_rect.pos = begin;
1684 local_rect.size = end - begin;
1685 canvas_item->edit_set_rect(local_rect);
1686
1687 } else {
1688 //ok, all that had to be done was done, now solve IK
1689
1690 Node2D *n2d = canvas_item->cast_to<Node2D>();
1691 Matrix32 final_xform = bone_orig_xform;
1692
1693 if (n2d) {
1694
1695 float total_len = 0;
1696 for (List<BoneIK>::Element *E = bone_ik_list.front(); E; E = E->next()) {
1697 if (E->prev())
1698 total_len += E->get().len;
1699 E->get().pos = E->get().node->get_global_transform().get_origin();
1700 }
1701
1702 {
1703
1704 final_xform.elements[2] += dto - dfrom; //final_xform.affine_inverse().basis_xform_inv(drag_vector);
1705 //n2d->set_global_transform(final_xform);
1706 }
1707
1708 CanvasItem *last = bone_ik_list.back()->get().node;
1709 if (!last)
1710 break;
1711
1712 Vector2 root_pos = last->get_global_transform().get_origin();
1713 Vector2 leaf_pos = final_xform.get_origin();
1714
1715 if ((leaf_pos.distance_to(root_pos)) > total_len) {
1716 //oops dude you went too far
1717 //print_line("TOO FAR!");
1718 Vector2 rel = leaf_pos - root_pos;
1719 rel = rel.normalized() * total_len;
1720 leaf_pos = root_pos + rel;
1721 }
1722
1723 bone_ik_list.front()->get().pos = leaf_pos;
1724
1725 //print_line("BONE IK LIST "+itos(bone_ik_list.size()));
1726
1727 if (bone_ik_list.size() > 2) {
1728 int solver_iterations = 64;
1729 float solver_k = 0.3;
1730
1731 for (int i = 0; i < solver_iterations; i++) {
1732
1733 for (List<BoneIK>::Element *E = bone_ik_list.front(); E; E = E->next()) {
1734
1735 if (E == bone_ik_list.back()) {
1736
1737 break;
1738 }
1739
1740 float len = E->next()->get().len;
1741
1742 if (E->next() == bone_ik_list.back()) {
1743
1744 //print_line("back");
1745
1746 Vector2 rel = E->get().pos - E->next()->get().pos;
1747 //print_line("PREV "+E->get().pos);
1748 Vector2 desired = E->next()->get().pos + rel.normalized() * len;
1749 //print_line("DESIRED "+desired);
1750 E->get().pos = E->get().pos.linear_interpolate(desired, solver_k);
1751 //print_line("POST "+E->get().pos);
1752
1753 } else if (E == bone_ik_list.front()) {
1754 //only adjust parent
1755 //print_line("front");
1756 Vector2 rel = E->next()->get().pos - E->get().pos;
1757 //print_line("PREV "+E->next()->get().pos);
1758 Vector2 desired = E->get().pos + rel.normalized() * len;
1759 //print_line("DESIRED "+desired);
1760 E->next()->get().pos = E->next()->get().pos.linear_interpolate(desired, solver_k);
1761 //print_line("POST "+E->next()->get().pos);
1762 } else {
1763
1764 Vector2 rel = E->next()->get().pos - E->get().pos;
1765 Vector2 cen = (E->next()->get().pos + E->get().pos) * 0.5;
1766 rel = rel.linear_interpolate(rel.normalized() * len, solver_k);
1767 rel *= 0.5;
1768 E->next()->get().pos = cen + rel;
1769 E->get().pos = cen - rel;
1770 //print_line("mid");
1771 }
1772 }
1773 }
1774 }
1775 }
1776
1777 for (List<BoneIK>::Element *E = bone_ik_list.back(); E; E = E->prev()) {
1778
1779 Node2D *n = E->get().node;
1780
1781 if (!E->prev()) {
1782 //last goes to what it was
1783 final_xform.set_origin(n->get_global_pos());
1784 n->set_global_transform(final_xform);
1785
1786 } else {
1787 Vector2 rel = (E->prev()->get().node->get_global_pos() - n->get_global_pos()).normalized();
1788 Vector2 rel2 = (E->prev()->get().pos - E->get().pos).normalized();
1789 float rot = rel.angle_to(rel2);
1790 if (n->get_global_transform().basis_determinant() < 0) {
1791 //mirrored, rotate the other way
1792 rot = -rot;
1793 }
1794
1795 n->rotate(rot);
1796 }
1797 }
1798
1799 break;
1800 }
1801 }
1802 }
1803
1804 if (p_event.type == InputEvent::KEY) {
1805
1806 const InputEventKey &k = p_event.key;
1807
1808 if (k.pressed && drag == DRAG_NONE) {
1809
1810 KeyMoveMODE move_mode = MOVE_VIEW_BASE;
1811 if (k.mod.alt) move_mode = MOVE_LOCAL_BASE;
1812 if (k.mod.control || k.mod.meta) move_mode = MOVE_LOCAL_WITH_ROT;
1813
1814 if (k.scancode == KEY_UP)
1815 _key_move(Vector2(0, -1), k.mod.shift, move_mode);
1816 else if (k.scancode == KEY_DOWN)
1817 _key_move(Vector2(0, 1), k.mod.shift, move_mode);
1818 else if (k.scancode == KEY_LEFT)
1819 _key_move(Vector2(-1, 0), k.mod.shift, move_mode);
1820 else if (k.scancode == KEY_RIGHT)
1821 _key_move(Vector2(1, 0), k.mod.shift, move_mode);
1822 else if (k.scancode == KEY_ESCAPE) {
1823 editor_selection->clear();
1824 viewport->update();
1825 } else
1826 return;
1827
1828 accept_event();
1829 }
1830 }
1831 }
1832
_viewport_draw()1833 void CanvasItemEditor::_viewport_draw() {
1834
1835 // TODO fetch the viewport?
1836
1837 Ref<Texture> pivot = get_icon("EditorPivot", "EditorIcons");
1838 _update_scrollbars();
1839 RID ci = viewport->get_canvas_item();
1840
1841 if (snap_show_grid) {
1842 Size2 s = viewport->get_size();
1843 int last_cell;
1844 Matrix32 xform = transform.affine_inverse();
1845
1846 if (snap_step.x != 0) {
1847 for (int i = 0; i < s.width; i++) {
1848 int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(i, 0)).x - snap_offset.x) / snap_step.x));
1849 if (i == 0)
1850 last_cell = cell;
1851 if (last_cell != cell)
1852 viewport->draw_line(Point2(i, 0), Point2(i, s.height), Color(0.3, 0.7, 1, 0.3));
1853 last_cell = cell;
1854 }
1855 }
1856
1857 if (snap_step.y != 0) {
1858 for (int i = 0; i < s.height; i++) {
1859 int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(0, i)).y - snap_offset.y) / snap_step.y));
1860 if (i == 0)
1861 last_cell = cell;
1862 if (last_cell != cell)
1863 viewport->draw_line(Point2(0, i), Point2(s.width, i), Color(0.3, 0.7, 1, 0.3));
1864 last_cell = cell;
1865 }
1866 }
1867 }
1868
1869 if (viewport->has_focus()) {
1870 Size2 size = viewport->get_size();
1871 if (v_scroll->is_visible())
1872 size.width -= v_scroll->get_size().width;
1873 if (h_scroll->is_visible())
1874 size.height -= h_scroll->get_size().height;
1875
1876 get_stylebox("EditorFocus", "EditorStyles")->draw(ci, Rect2(Point2(), size));
1877 }
1878
1879 Ref<Texture> lock = get_icon("Lock", "EditorIcons");
1880 Ref<Texture> group = get_icon("Group", "EditorIcons");
1881
1882 VisualServer::get_singleton()->canvas_item_set_clip(ci, true);
1883
1884 bool single = get_single_item() != NULL;
1885
1886 Map<Node *, Object *> &selection = editor_selection->get_selection();
1887
1888 bool pivot_found = false;
1889
1890 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
1891
1892 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
1893 if (!canvas_item || !canvas_item->is_visible())
1894 continue;
1895 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
1896 continue;
1897 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
1898 if (!se)
1899 continue;
1900
1901 Rect2 rect = canvas_item->get_item_rect();
1902
1903 Matrix32 xform = transform * canvas_item->get_global_transform_with_canvas();
1904 VisualServer::get_singleton()->canvas_item_add_set_transform(ci, xform);
1905
1906 Vector2 endpoints[4] = {
1907
1908 xform.xform(rect.pos),
1909 xform.xform(rect.pos + Vector2(rect.size.x, 0)),
1910 xform.xform(rect.pos + rect.size),
1911 xform.xform(rect.pos + Vector2(0, rect.size.y))
1912 };
1913
1914 Color c = Color(1, 0.6, 0.4, 0.7);
1915
1916 VisualServer::get_singleton()->canvas_item_add_set_transform(ci, Matrix32());
1917
1918 for (int i = 0; i < 4; i++) {
1919 viewport->draw_line(endpoints[i], endpoints[(i + 1) % 4], c, 2);
1920 }
1921
1922 if (single && (tool == TOOL_SELECT || tool == TOOL_MOVE || tool == TOOL_ROTATE || tool == TOOL_EDIT_PIVOT)) { //kind of sucks
1923
1924 if (canvas_item->cast_to<Node2D>()) {
1925
1926 if (canvas_item->cast_to<Node2D>()->edit_has_pivot()) {
1927 viewport->draw_texture(pivot, xform.get_origin() + (-pivot->get_size() / 2).floor());
1928 can_move_pivot = true;
1929 pivot_found = true;
1930 }
1931 }
1932
1933 if (tool == TOOL_SELECT) {
1934
1935 for (int i = 0; i < 4; i++) {
1936
1937 int prev = (i + 3) % 4;
1938 int next = (i + 1) % 4;
1939
1940 Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized();
1941 ofs *= 1.4144 * (select_handle->get_size().width / 2);
1942
1943 select_handle->draw(ci, (endpoints[i] + ofs - (select_handle->get_size() / 2)).floor());
1944
1945 ofs = (endpoints[i] + endpoints[next]) / 2;
1946 ofs += (endpoints[next] - endpoints[i]).tangent().normalized() * (select_handle->get_size().width / 2);
1947
1948 select_handle->draw(ci, (ofs - (select_handle->get_size() / 2)).floor());
1949 }
1950 }
1951 }
1952
1953 //DRAW_EMPTY_RECT( Rect2( current_window->get_scroll()-Point2(1,1), get_size()+Size2(2,2)), Color(0.8,0.8,1.0,0.8) );
1954 //E->get().last_rect = rect;
1955 }
1956
1957 pivot_button->set_disabled(!pivot_found);
1958 VisualServer::get_singleton()->canvas_item_add_set_transform(ci, Matrix32());
1959
1960 Color x_axis_color(1.0, 0.4, 0.4, 0.6);
1961 Color y_axis_color(0.4, 1.0, 0.4, 0.6);
1962 Color area_axis_color(0.4, 0.4, 1.0, 0.4);
1963 Color rotate_color(0.4, 0.7, 1.0, 0.8);
1964
1965 VisualServer::get_singleton()->canvas_item_add_line(ci, Point2(h_scroll->get_min(), 0) + transform.get_origin(), Point2(h_scroll->get_max(), 0) + transform.get_origin(), x_axis_color);
1966 VisualServer::get_singleton()->canvas_item_add_line(ci, Point2(0, v_scroll->get_min()) + transform.get_origin(), Point2(0, v_scroll->get_max()) + transform.get_origin(), y_axis_color);
1967
1968 if (box_selecting) {
1969
1970 Point2 bsfrom = transform.xform(drag_from);
1971 Point2 bsto = transform.xform(box_selecting_to);
1972
1973 VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(bsfrom, bsto - bsfrom), Color(0.7, 0.7, 1.0, 0.3));
1974 }
1975
1976 if (drag == DRAG_ROTATE) {
1977 VisualServer::get_singleton()->canvas_item_add_line(ci, transform.xform(display_rotate_from), transform.xform(display_rotate_to), rotate_color);
1978 }
1979
1980 Size2 screen_size = Size2(Globals::get_singleton()->get("display/width"), Globals::get_singleton()->get("display/height"));
1981
1982 Vector2 screen_endpoints[4] = {
1983 transform.xform(Vector2(0, 0)),
1984 transform.xform(Vector2(screen_size.width, 0)),
1985 transform.xform(Vector2(screen_size.width, screen_size.height)),
1986 transform.xform(Vector2(0, screen_size.height))
1987 };
1988
1989 for (int i = 0; i < 4; i++) {
1990
1991 VisualServer::get_singleton()->canvas_item_add_line(ci, screen_endpoints[i], screen_endpoints[(i + 1) % 4], area_axis_color);
1992 }
1993
1994 for (List<LockList>::Element *E = lock_list.front(); E; E = E->next()) {
1995
1996 Vector2 ofs = transform.xform(E->get().pos);
1997 if (E->get().lock) {
1998
1999 lock->draw(ci, ofs);
2000 ofs.x += lock->get_width();
2001 }
2002 if (E->get().group) {
2003
2004 group->draw(ci, ofs);
2005 }
2006 }
2007
2008 int bone_width = EditorSettings::get_singleton()->get("2d_editor/bone_width");
2009 Color bone_color1 = EditorSettings::get_singleton()->get("2d_editor/bone_color1");
2010 Color bone_color2 = EditorSettings::get_singleton()->get("2d_editor/bone_color2");
2011 Color bone_ik_color = EditorSettings::get_singleton()->get("2d_editor/bone_ik_color");
2012 Color bone_selected_color = EditorSettings::get_singleton()->get("2d_editor/bone_selected_color");
2013
2014 for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
2015
2016 E->get().from = Vector2();
2017 E->get().to = Vector2();
2018
2019 Object *obj = ObjectDB::get_instance(E->get().bone);
2020 if (!obj)
2021 continue;
2022
2023 Node2D *n2d = obj->cast_to<Node2D>();
2024 if (!n2d)
2025 continue;
2026
2027 if (!n2d->get_parent())
2028 continue;
2029
2030 CanvasItem *pi = n2d->get_parent_item();
2031
2032 Node2D *pn2d = n2d->get_parent()->cast_to<Node2D>();
2033
2034 if (!pn2d)
2035 continue;
2036
2037 Vector2 from = transform.xform(pn2d->get_global_pos());
2038 Vector2 to = transform.xform(n2d->get_global_pos());
2039
2040 E->get().from = from;
2041 E->get().to = to;
2042
2043 Vector2 rel = to - from;
2044 Vector2 relt = rel.tangent().normalized() * bone_width;
2045
2046 Vector<Vector2> bone_shape;
2047 bone_shape.push_back(from);
2048 bone_shape.push_back(from + rel * 0.2 + relt);
2049 bone_shape.push_back(to);
2050 bone_shape.push_back(from + rel * 0.2 - relt);
2051 Vector<Color> colors;
2052 if (pi->has_meta("_edit_ik_")) {
2053
2054 colors.push_back(bone_ik_color);
2055 colors.push_back(bone_ik_color);
2056 colors.push_back(bone_ik_color);
2057 colors.push_back(bone_ik_color);
2058 } else {
2059 colors.push_back(bone_color1);
2060 colors.push_back(bone_color2);
2061 colors.push_back(bone_color1);
2062 colors.push_back(bone_color2);
2063 }
2064
2065 VisualServer::get_singleton()->canvas_item_add_primitive(ci, bone_shape, colors, Vector<Vector2>(), RID());
2066
2067 if (editor_selection->is_selected(pi)) {
2068 for (int i = 0; i < bone_shape.size(); i++) {
2069
2070 VisualServer::get_singleton()->canvas_item_add_line(ci, bone_shape[i], bone_shape[(i + 1) % bone_shape.size()], bone_selected_color, 2);
2071 }
2072 }
2073 }
2074 }
2075
_notification(int p_what)2076 void CanvasItemEditor::_notification(int p_what) {
2077
2078 if (p_what == NOTIFICATION_FIXED_PROCESS) {
2079
2080 List<Node *> &selection = editor_selection->get_selected_node_list();
2081
2082 bool all_control = true;
2083 bool has_control = false;
2084
2085 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2086
2087 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2088 if (!canvas_item || !canvas_item->is_visible())
2089 continue;
2090
2091 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2092 continue;
2093
2094 if (canvas_item->cast_to<Control>())
2095 has_control = true;
2096 else
2097 all_control = false;
2098
2099 CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
2100 if (!se)
2101 continue;
2102
2103 Rect2 r = canvas_item->get_item_rect();
2104
2105 Matrix32 xform = canvas_item->get_transform();
2106
2107 if (r != se->prev_rect || xform != se->prev_xform) {
2108 viewport->update();
2109 se->prev_rect = r;
2110 se->prev_xform = xform;
2111 }
2112 }
2113
2114 bool show_anchor = all_control && has_control;
2115 if (show_anchor != !anchor_menu->is_hidden()) {
2116 if (show_anchor)
2117 anchor_menu->show();
2118 else
2119 anchor_menu->hide();
2120 }
2121
2122 for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
2123
2124 Object *b = ObjectDB::get_instance(E->get().bone);
2125 if (!b) {
2126
2127 viewport->update();
2128 break;
2129 }
2130
2131 Node2D *b2 = b->cast_to<Node2D>();
2132 if (!b2) {
2133 continue;
2134 }
2135
2136 if (b2->get_global_transform() != E->get().xform) {
2137
2138 E->get().xform = b2->get_global_transform();
2139 viewport->update();
2140 }
2141 }
2142 }
2143
2144 if (p_what == NOTIFICATION_ENTER_TREE) {
2145
2146 select_sb->set_texture(get_icon("EditorRect2D", "EditorIcons"));
2147 for (int i = 0; i < 4; i++) {
2148 select_sb->set_margin_size(Margin(i), 4);
2149 select_sb->set_default_margin(Margin(i), 4);
2150 }
2151
2152 select_button->set_icon(get_icon("ToolSelect", "EditorIcons"));
2153 list_select_button->set_icon(get_icon("ListSelect", "EditorIcons"));
2154 move_button->set_icon(get_icon("ToolMove", "EditorIcons"));
2155 rotate_button->set_icon(get_icon("ToolRotate", "EditorIcons"));
2156 pan_button->set_icon(get_icon("ToolPan", "EditorIcons"));
2157 pivot_button->set_icon(get_icon("EditPivot", "EditorIcons"));
2158 select_handle = get_icon("EditorHandle", "EditorIcons");
2159 lock_button->set_icon(get_icon("Lock", "EditorIcons"));
2160 unlock_button->set_icon(get_icon("Unlock", "EditorIcons"));
2161 group_button->set_icon(get_icon("Group", "EditorIcons"));
2162 ungroup_button->set_icon(get_icon("Ungroup", "EditorIcons"));
2163 key_insert_button->set_icon(get_icon("Key", "EditorIcons"));
2164
2165 //anchor_menu->add_icon_override("Align Top Left");
2166 anchor_menu->set_icon(get_icon("Anchor", "EditorIcons"));
2167 PopupMenu *p = anchor_menu->get_popup();
2168
2169 p->add_icon_item(get_icon("ControlAlignTopLeft", "EditorIcons"), "Top Left", ANCHOR_ALIGN_TOP_LEFT);
2170 p->add_icon_item(get_icon("ControlAlignTopRight", "EditorIcons"), "Top Right", ANCHOR_ALIGN_TOP_RIGHT);
2171 p->add_icon_item(get_icon("ControlAlignBottomRight", "EditorIcons"), "Bottom Right", ANCHOR_ALIGN_BOTTOM_RIGHT);
2172 p->add_icon_item(get_icon("ControlAlignBottomLeft", "EditorIcons"), "Bottom Left", ANCHOR_ALIGN_BOTTOM_LEFT);
2173 p->add_separator();
2174 p->add_icon_item(get_icon("ControlAlignLeftCenter", "EditorIcons"), "Center Left", ANCHOR_ALIGN_CENTER_LEFT);
2175 p->add_icon_item(get_icon("ControlAlignTopCenter", "EditorIcons"), "Center Top", ANCHOR_ALIGN_CENTER_TOP);
2176 p->add_icon_item(get_icon("ControlAlignRightCenter", "EditorIcons"), "Center Right", ANCHOR_ALIGN_CENTER_RIGHT);
2177 p->add_icon_item(get_icon("ControlAlignBottomCenter", "EditorIcons"), "Center Bottom", ANCHOR_ALIGN_CENTER_BOTTOM);
2178 p->add_icon_item(get_icon("ControlAlignCenter", "EditorIcons"), "Center", ANCHOR_ALIGN_CENTER);
2179 p->add_separator();
2180 p->add_icon_item(get_icon("ControlAlignLeftWide", "EditorIcons"), "Left Wide", ANCHOR_ALIGN_LEFT_WIDE);
2181 p->add_icon_item(get_icon("ControlAlignTopWide", "EditorIcons"), "Top Wide", ANCHOR_ALIGN_TOP_WIDE);
2182 p->add_icon_item(get_icon("ControlAlignRightWide", "EditorIcons"), "Right Wide", ANCHOR_ALIGN_RIGHT_WIDE);
2183 p->add_icon_item(get_icon("ControlAlignBottomWide", "EditorIcons"), "Bottom Wide", ANCHOR_ALIGN_BOTTOM_WIDE);
2184 p->add_icon_item(get_icon("ControlVcenterWide", "EditorIcons"), "VCenter Wide ", ANCHOR_ALIGN_VCENTER_WIDE);
2185 p->add_icon_item(get_icon("ControlHcenterWide", "EditorIcons"), "HCenter Wide ", ANCHOR_ALIGN_HCENTER_WIDE);
2186 p->add_separator();
2187 p->add_icon_item(get_icon("ControlAlignWide", "EditorIcons"), "Full Rect", ANCHOR_ALIGN_WIDE);
2188
2189 AnimationPlayerEditor::singleton->get_key_editor()->connect("visibility_changed", this, "_keying_changed");
2190 _keying_changed();
2191 }
2192
2193 if (p_what == NOTIFICATION_READY) {
2194
2195 get_tree()->connect("node_removed", this, "_node_removed");
2196 }
2197
2198 if (p_what == NOTIFICATION_DRAW) {
2199 }
2200 }
2201
edit(CanvasItem * p_canvas_item)2202 void CanvasItemEditor::edit(CanvasItem *p_canvas_item) {
2203
2204 drag = DRAG_NONE;
2205
2206 editor_selection->clear(); //_clear_canvas_items();
2207 editor_selection->add_node(p_canvas_item);
2208 //_add_canvas_item(p_canvas_item);
2209 viewport->update();
2210 }
2211
_find_canvas_items_span(Node * p_node,Rect2 & r_rect,const Matrix32 & p_xform)2212 void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2 &r_rect, const Matrix32 &p_xform) {
2213
2214 if (!p_node)
2215 return;
2216
2217 CanvasItem *c = p_node->cast_to<CanvasItem>();
2218
2219 for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
2220
2221 // CanvasItem *r=NULL;
2222
2223 if (c && !c->is_set_as_toplevel())
2224 _find_canvas_items_span(p_node->get_child(i), r_rect, p_xform * c->get_transform());
2225 else
2226 _find_canvas_items_span(p_node->get_child(i), r_rect, Matrix32());
2227 }
2228
2229 if (c && c->is_visible()) {
2230
2231 Rect2 rect = c->get_item_rect();
2232 Matrix32 xform = p_xform * c->get_transform();
2233
2234 LockList lock;
2235 lock.lock = c->has_meta("_edit_lock_");
2236 lock.group = c->has_meta("_edit_group_");
2237
2238 if (lock.group || lock.lock) {
2239 lock.pos = xform.xform(rect.pos);
2240 lock_list.push_back(lock);
2241 }
2242
2243 if (c->has_meta("_edit_bone_")) {
2244
2245 ObjectID id = c->get_instance_ID();
2246 if (!bone_list.has(id)) {
2247 BoneList bone;
2248 bone.bone = id;
2249 bone_list[id] = bone;
2250 }
2251
2252 bone_list[id].last_pass = bone_last_frame;
2253 }
2254
2255 r_rect.expand_to(xform.xform(rect.pos));
2256 r_rect.expand_to(xform.xform(rect.pos + Point2(rect.size.x, 0)));
2257 r_rect.expand_to(xform.xform(rect.pos + Point2(0, rect.size.y)));
2258 r_rect.expand_to(xform.xform(rect.pos + rect.size));
2259 }
2260 }
2261
_update_scrollbars()2262 void CanvasItemEditor::_update_scrollbars() {
2263
2264 updating_scroll = true;
2265
2266 Size2 size = viewport->get_size();
2267 Size2 hmin = h_scroll->get_minimum_size();
2268 Size2 vmin = v_scroll->get_minimum_size();
2269
2270 v_scroll->set_begin(Point2(size.width - vmin.width, 0));
2271 v_scroll->set_end(Point2(size.width, size.height));
2272
2273 h_scroll->set_begin(Point2(0, size.height - hmin.height));
2274 h_scroll->set_end(Point2(size.width - vmin.width, size.height));
2275
2276 Size2 screen_rect = Size2(Globals::get_singleton()->get("display/width"), Globals::get_singleton()->get("display/height"));
2277
2278 Rect2 local_rect = Rect2(Point2(), viewport->get_size() - Size2(vmin.width, hmin.height));
2279
2280 Rect2 canvas_item_rect = Rect2(Point2(), screen_rect);
2281
2282 lock_list.clear();
2283 bone_last_frame++;
2284
2285 if (editor->get_edited_scene())
2286 _find_canvas_items_span(editor->get_edited_scene(), canvas_item_rect, Matrix32());
2287
2288 List<Map<ObjectID, BoneList>::Element *> bone_to_erase;
2289
2290 for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
2291
2292 if (E->get().last_pass != bone_last_frame) {
2293 bone_to_erase.push_back(E);
2294 }
2295 }
2296
2297 while (bone_to_erase.size()) {
2298 bone_list.erase(bone_to_erase.front()->get());
2299 bone_to_erase.pop_front();
2300 }
2301
2302 //expand area so it's easier to do animations and stuff at 0,0
2303 canvas_item_rect.size += screen_rect * 2;
2304 canvas_item_rect.pos -= screen_rect;
2305
2306 Point2 ofs;
2307
2308 if (canvas_item_rect.size.height <= (local_rect.size.y / zoom)) {
2309
2310 v_scroll->hide();
2311 ofs.y = canvas_item_rect.pos.y;
2312 } else {
2313
2314 v_scroll->show();
2315 v_scroll->set_min(canvas_item_rect.pos.y);
2316 v_scroll->set_max(canvas_item_rect.pos.y + canvas_item_rect.size.y);
2317 v_scroll->set_page(local_rect.size.y / zoom);
2318 if (first_update) {
2319 //so 0,0 is visible
2320 v_scroll->set_val(-10);
2321 h_scroll->set_val(-10);
2322 first_update = false;
2323 }
2324
2325 ofs.y = v_scroll->get_val();
2326 }
2327
2328 if (canvas_item_rect.size.width <= (local_rect.size.x / zoom)) {
2329
2330 h_scroll->hide();
2331 ofs.x = canvas_item_rect.pos.x;
2332 } else {
2333
2334 h_scroll->show();
2335 h_scroll->set_min(canvas_item_rect.pos.x);
2336 h_scroll->set_max(canvas_item_rect.pos.x + canvas_item_rect.size.x);
2337 h_scroll->set_page(local_rect.size.x / zoom);
2338 ofs.x = h_scroll->get_val();
2339 }
2340
2341 // transform=Matrix32();
2342 transform.elements[2] = -ofs * zoom;
2343 editor->get_scene_root()->set_global_canvas_transform(transform);
2344
2345 updating_scroll = false;
2346
2347 // transform.scale_basis(Vector2(zoom,zoom));
2348 }
2349
_update_scroll(float)2350 void CanvasItemEditor::_update_scroll(float) {
2351
2352 if (updating_scroll)
2353 return;
2354
2355 Point2 ofs;
2356 ofs.x = h_scroll->get_val();
2357 ofs.y = v_scroll->get_val();
2358
2359 // current_window->set_scroll(-ofs);
2360
2361 transform = Matrix32();
2362
2363 transform.scale_basis(Size2(zoom, zoom));
2364 transform.elements[2] = -ofs;
2365
2366 editor->get_scene_root()->set_global_canvas_transform(transform);
2367
2368 viewport->update();
2369 }
2370
_set_anchor(Control::AnchorType p_left,Control::AnchorType p_top,Control::AnchorType p_right,Control::AnchorType p_bottom)2371 void CanvasItemEditor::_set_anchor(Control::AnchorType p_left, Control::AnchorType p_top, Control::AnchorType p_right, Control::AnchorType p_bottom) {
2372 List<Node *> &selection = editor_selection->get_selected_node_list();
2373
2374 undo_redo->create_action(TTR("Change Anchors"));
2375 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2376
2377 Control *c = E->get()->cast_to<Control>();
2378
2379 undo_redo->add_do_method(c, "set_anchor", MARGIN_LEFT, p_left);
2380 undo_redo->add_do_method(c, "set_anchor", MARGIN_TOP, p_top);
2381 undo_redo->add_do_method(c, "set_anchor", MARGIN_RIGHT, p_right);
2382 undo_redo->add_do_method(c, "set_anchor", MARGIN_BOTTOM, p_bottom);
2383 undo_redo->add_undo_method(c, "set_anchor", MARGIN_LEFT, c->get_anchor(MARGIN_LEFT));
2384 undo_redo->add_undo_method(c, "set_anchor", MARGIN_TOP, c->get_anchor(MARGIN_TOP));
2385 undo_redo->add_undo_method(c, "set_anchor", MARGIN_RIGHT, c->get_anchor(MARGIN_RIGHT));
2386 undo_redo->add_undo_method(c, "set_anchor", MARGIN_BOTTOM, c->get_anchor(MARGIN_BOTTOM));
2387 }
2388
2389 undo_redo->commit_action();
2390 }
2391
_popup_callback(int p_op)2392 void CanvasItemEditor::_popup_callback(int p_op) {
2393
2394 last_option = MenuOption(p_op);
2395 switch (p_op) {
2396
2397 case SNAP_USE: {
2398 snap_grid = !snap_grid;
2399 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE);
2400 edit_menu->get_popup()->set_item_checked(idx, snap_grid);
2401 } break;
2402 case SNAP_SHOW_GRID: {
2403 snap_show_grid = !snap_show_grid;
2404 int idx = edit_menu->get_popup()->get_item_index(SNAP_SHOW_GRID);
2405 edit_menu->get_popup()->set_item_checked(idx, snap_show_grid);
2406 viewport->update();
2407 } break;
2408 case SNAP_USE_ROTATION: {
2409 snap_rotation = !snap_rotation;
2410 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_ROTATION);
2411 edit_menu->get_popup()->set_item_checked(idx, snap_rotation);
2412 } break;
2413 case SNAP_RELATIVE: {
2414 snap_relative = !snap_relative;
2415 int idx = edit_menu->get_popup()->get_item_index(SNAP_RELATIVE);
2416 edit_menu->get_popup()->set_item_checked(idx, snap_relative);
2417 } break;
2418 case SNAP_USE_PIXEL: {
2419 snap_pixel = !snap_pixel;
2420 int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL);
2421 edit_menu->get_popup()->set_item_checked(idx, snap_pixel);
2422 } break;
2423 case SNAP_CONFIGURE: {
2424 ((SnapDialog *)snap_dialog)->set_fields(snap_offset, snap_step, snap_rotation_offset, snap_rotation_step);
2425 snap_dialog->popup_centered(Size2(220, 160));
2426 } break;
2427 case ZOOM_IN: {
2428 if (zoom > MAX_ZOOM)
2429 return;
2430 zoom = zoom * (1.0 / 0.5);
2431 _update_scroll(0);
2432 viewport->update();
2433 return;
2434 } break;
2435 case ZOOM_OUT: {
2436 if (zoom < MIN_ZOOM)
2437 return;
2438
2439 zoom = zoom * 0.5;
2440 _update_scroll(0);
2441 viewport->update();
2442 return;
2443
2444 } break;
2445 case ZOOM_RESET: {
2446
2447 zoom = 1;
2448 _update_scroll(0);
2449 viewport->update();
2450 return;
2451
2452 } break;
2453 case ZOOM_SET: {
2454
2455 updating_value_dialog = true;
2456
2457 dialog_label->set_text(TTR("Zoom (%):"));
2458 dialog_val->set_min(0.1);
2459 dialog_val->set_step(0.1);
2460 dialog_val->set_max(800);
2461 dialog_val->set_val(zoom * 100);
2462 value_dialog->popup_centered(Size2(200, 85));
2463 updating_value_dialog = false;
2464
2465 } break;
2466 case LOCK_SELECTED: {
2467
2468 List<Node *> &selection = editor_selection->get_selected_node_list();
2469
2470 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2471
2472 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2473 if (!canvas_item || !canvas_item->is_visible())
2474 continue;
2475
2476 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2477 continue;
2478
2479 canvas_item->set_meta("_edit_lock_", true);
2480 emit_signal("item_lock_status_changed");
2481 }
2482 viewport->update();
2483 } break;
2484 case UNLOCK_SELECTED: {
2485
2486 List<Node *> &selection = editor_selection->get_selected_node_list();
2487
2488 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2489
2490 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2491 if (!canvas_item || !canvas_item->is_visible())
2492 continue;
2493
2494 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2495 continue;
2496
2497 canvas_item->set_meta("_edit_lock_", Variant());
2498 emit_signal("item_lock_status_changed");
2499 }
2500
2501 viewport->update();
2502
2503 } break;
2504 case GROUP_SELECTED: {
2505
2506 List<Node *> &selection = editor_selection->get_selected_node_list();
2507
2508 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2509
2510 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2511 if (!canvas_item || !canvas_item->is_visible())
2512 continue;
2513
2514 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2515 continue;
2516
2517 canvas_item->set_meta("_edit_group_", true);
2518 emit_signal("item_group_status_changed");
2519 }
2520 viewport->update();
2521 } break;
2522 case UNGROUP_SELECTED: {
2523
2524 List<Node *> &selection = editor_selection->get_selected_node_list();
2525
2526 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2527
2528 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2529 if (!canvas_item || !canvas_item->is_visible())
2530 continue;
2531
2532 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2533 continue;
2534
2535 canvas_item->set_meta("_edit_group_", Variant());
2536 emit_signal("item_group_status_changed");
2537 }
2538
2539 viewport->update();
2540
2541 } break;
2542
2543 case EXPAND_TO_PARENT: {
2544
2545 List<Node *> &selection = editor_selection->get_selected_node_list();
2546
2547 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2548
2549 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2550 if (!canvas_item || !canvas_item->is_visible())
2551 continue;
2552
2553 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2554 continue;
2555
2556 Control *c = canvas_item->cast_to<Control>();
2557 if (!c)
2558 continue;
2559 c->set_area_as_parent_rect();
2560 }
2561
2562 viewport->update();
2563
2564 } break;
2565
2566 case ALIGN_VERTICAL: {
2567 #if 0
2568 if ( ref_item && canvas_items.size() > 1 ) {
2569 Vector2 ref_pos = ref_item->get_global_transform().elements[2];
2570 Rect2 ref_r = ref_item->get_item_rect();
2571 for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) {
2572 CanvasItem *it_curr = E->key();
2573 if ( it_curr == ref_item ) continue;
2574 Vector2 v = it_curr->get_global_transform().elements[2];
2575 Rect2 r = it_curr->get_item_rect();
2576 r.pos.x = ( ref_pos.x + ref_r.size.x / 2 ) - ( v.x + r.size.x / 2 );
2577 it_curr->edit_set_rect( r );
2578 }
2579 viewport->update();
2580 }
2581 #endif
2582 } break;
2583
2584 case ALIGN_HORIZONTAL: {
2585 #if 0
2586 if ( ref_item && canvas_items.size() > 1 ) {
2587 Vector2 ref_pos = ref_item->get_global_transform().elements[2];
2588 Rect2 ref_r = ref_item->get_item_rect();
2589 for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) {
2590 CanvasItem *it_curr = E->key();
2591 if ( it_curr == ref_item ) continue;
2592 Vector2 v = it_curr->get_global_transform().elements[2];
2593 Rect2 r = it_curr->get_item_rect();
2594 r.pos.y = ( ref_pos.y + ref_r.size.y / 2 ) - ( v.y + r.size.y / 2 );
2595 it_curr->edit_set_rect( r );
2596 }
2597 viewport->update();
2598 }
2599 #endif
2600 } break;
2601
2602 case SPACE_HORIZONTAL: {
2603 //space_selected_items< proj_vector2_x, compare_items_x >();
2604 } break;
2605
2606 case SPACE_VERTICAL: {
2607 //space_selected_items< proj_vector2_y, compare_items_y >();
2608 } break;
2609 case ANCHOR_ALIGN_TOP_LEFT: {
2610 _set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN);
2611 } break;
2612 case ANCHOR_ALIGN_TOP_RIGHT: {
2613 _set_anchor(ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN);
2614 } break;
2615 case ANCHOR_ALIGN_BOTTOM_LEFT: {
2616 _set_anchor(ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END);
2617 } break;
2618 case ANCHOR_ALIGN_BOTTOM_RIGHT: {
2619 _set_anchor(ANCHOR_END, ANCHOR_END, ANCHOR_END, ANCHOR_END);
2620 } break;
2621 case ANCHOR_ALIGN_CENTER_LEFT: {
2622 _set_anchor(ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER);
2623 } break;
2624 case ANCHOR_ALIGN_CENTER_RIGHT: {
2625
2626 _set_anchor(ANCHOR_END, ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER);
2627 } break;
2628 case ANCHOR_ALIGN_CENTER_TOP: {
2629 _set_anchor(ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_BEGIN);
2630 } break;
2631 case ANCHOR_ALIGN_CENTER_BOTTOM: {
2632 _set_anchor(ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER, ANCHOR_END);
2633 } break;
2634 case ANCHOR_ALIGN_CENTER: {
2635 _set_anchor(ANCHOR_CENTER, ANCHOR_CENTER, ANCHOR_CENTER, ANCHOR_CENTER);
2636 } break;
2637 case ANCHOR_ALIGN_TOP_WIDE: {
2638 _set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN);
2639 } break;
2640 case ANCHOR_ALIGN_LEFT_WIDE: {
2641 _set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END);
2642 } break;
2643 case ANCHOR_ALIGN_RIGHT_WIDE: {
2644 _set_anchor(ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END);
2645 } break;
2646 case ANCHOR_ALIGN_BOTTOM_WIDE: {
2647 _set_anchor(ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END, ANCHOR_END);
2648 } break;
2649 case ANCHOR_ALIGN_VCENTER_WIDE: {
2650 _set_anchor(ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_END);
2651 } break;
2652 case ANCHOR_ALIGN_HCENTER_WIDE: {
2653 _set_anchor(ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER);
2654 } break;
2655 case ANCHOR_ALIGN_WIDE: {
2656 _set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END);
2657 } break;
2658
2659 case ANIM_INSERT_KEY:
2660 case ANIM_INSERT_KEY_EXISTING: {
2661
2662 bool existing = p_op == ANIM_INSERT_KEY_EXISTING;
2663
2664 Map<Node *, Object *> &selection = editor_selection->get_selection();
2665
2666 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2667
2668 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
2669 if (!canvas_item || !canvas_item->is_visible())
2670 continue;
2671
2672 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2673 continue;
2674
2675 if (canvas_item->cast_to<Node2D>()) {
2676 Node2D *n2d = canvas_item->cast_to<Node2D>();
2677
2678 if (key_pos)
2679 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d, "transform/pos", n2d->get_pos(), existing);
2680 if (key_rot)
2681 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d, "transform/rot", Math::rad2deg(n2d->get_rot()), existing);
2682 if (key_scale)
2683 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d, "transform/scale", n2d->get_scale(), existing);
2684
2685 if (n2d->has_meta("_edit_bone_") && n2d->get_parent_item()) {
2686 //look for an IK chain
2687 List<Node2D *> ik_chain;
2688
2689 Node2D *n = n2d->get_parent_item()->cast_to<Node2D>();
2690 bool has_chain = false;
2691
2692 while (n) {
2693
2694 ik_chain.push_back(n);
2695 if (n->has_meta("_edit_ik_")) {
2696 has_chain = true;
2697 break;
2698 }
2699
2700 if (!n->get_parent_item())
2701 break;
2702 n = n->get_parent_item()->cast_to<Node2D>();
2703 }
2704
2705 if (has_chain && ik_chain.size()) {
2706
2707 for (List<Node2D *>::Element *F = ik_chain.front(); F; F = F->next()) {
2708
2709 if (key_pos)
2710 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/pos", F->get()->get_pos(), existing);
2711 if (key_rot)
2712 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/rot", Math::rad2deg(F->get()->get_rot()), existing);
2713 if (key_scale)
2714 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/scale", F->get()->get_scale(), existing);
2715 }
2716 }
2717 }
2718
2719 } else if (canvas_item->cast_to<Control>()) {
2720
2721 Control *ctrl = canvas_item->cast_to<Control>();
2722
2723 if (key_pos)
2724 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl, "rect/pos", ctrl->get_pos(), existing);
2725 if (key_scale)
2726 AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl, "rect/size", ctrl->get_size(), existing);
2727 }
2728 }
2729
2730 } break;
2731 case ANIM_INSERT_POS: {
2732
2733 key_pos = key_loc_button->is_pressed();
2734 } break;
2735 case ANIM_INSERT_ROT: {
2736
2737 key_rot = key_rot_button->is_pressed();
2738 } break;
2739 case ANIM_INSERT_SCALE: {
2740
2741 key_scale = key_scale_button->is_pressed();
2742 } break;
2743 /*
2744 case ANIM_INSERT_POS_ROT
2745 case ANIM_INSERT_POS_SCALE:
2746 case ANIM_INSERT_ROT_SCALE:
2747 case ANIM_INSERT_POS_ROT_SCALE: {
2748
2749 static const bool key_toggles[7][3]={
2750 {true,false,false},
2751 {false,true,false},
2752 {false,false,true},
2753 {true,true,false},
2754 {true,false,true},
2755 {false,true,true},
2756 {true,true,true}
2757 };
2758 key_pos=key_toggles[p_op-ANIM_INSERT_POS][0];
2759 key_rot=key_toggles[p_op-ANIM_INSERT_POS][1];
2760 key_scale=key_toggles[p_op-ANIM_INSERT_POS][2];
2761
2762 for(int i=ANIM_INSERT_POS;i<=ANIM_INSERT_POS_ROT_SCALE;i++) {
2763 int idx = animation_menu->get_popup()->get_item_index(i);
2764 animation_menu->get_popup()->set_item_checked(idx,i==p_op);
2765 }
2766
2767 } break;*/
2768 case ANIM_COPY_POSE: {
2769
2770 pose_clipboard.clear();
2771
2772 Map<Node *, Object *> &selection = editor_selection->get_selection();
2773
2774 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2775
2776 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
2777 if (!canvas_item || !canvas_item->is_visible())
2778 continue;
2779
2780 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2781 continue;
2782
2783 if (canvas_item->cast_to<Node2D>()) {
2784
2785 Node2D *n2d = canvas_item->cast_to<Node2D>();
2786 PoseClipboard pc;
2787 pc.pos = n2d->get_pos();
2788 pc.rot = n2d->get_rot();
2789 pc.scale = n2d->get_scale();
2790 pc.id = n2d->get_instance_ID();
2791 pose_clipboard.push_back(pc);
2792 }
2793 }
2794
2795 } break;
2796 case ANIM_PASTE_POSE: {
2797
2798 if (!pose_clipboard.size())
2799 break;
2800
2801 undo_redo->create_action(TTR("Paste Pose"));
2802 for (List<PoseClipboard>::Element *E = pose_clipboard.front(); E; E = E->next()) {
2803
2804 Object *o = ObjectDB::get_instance(E->get().id);
2805 if (!o)
2806 continue;
2807 Node2D *n2d = o->cast_to<Node2D>();
2808 if (!n2d)
2809 continue;
2810 undo_redo->add_do_method(n2d, "set_pos", E->get().pos);
2811 undo_redo->add_do_method(n2d, "set_rot", E->get().rot);
2812 undo_redo->add_do_method(n2d, "set_scale", E->get().scale);
2813 undo_redo->add_undo_method(n2d, "set_pos", n2d->get_pos());
2814 undo_redo->add_undo_method(n2d, "set_rot", n2d->get_rot());
2815 undo_redo->add_undo_method(n2d, "set_scale", n2d->get_scale());
2816 }
2817 undo_redo->commit_action();
2818
2819 } break;
2820 case ANIM_CLEAR_POSE: {
2821
2822 Map<Node *, Object *> &selection = editor_selection->get_selection();
2823
2824 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2825
2826 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
2827 if (!canvas_item || !canvas_item->is_visible())
2828 continue;
2829
2830 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2831 continue;
2832
2833 if (canvas_item->cast_to<Node2D>()) {
2834 Node2D *n2d = canvas_item->cast_to<Node2D>();
2835
2836 if (key_pos)
2837 n2d->set_pos(Vector2());
2838 if (key_rot)
2839 n2d->set_rot(0);
2840 if (key_scale)
2841 n2d->set_scale(Vector2(1, 1));
2842 } else if (canvas_item->cast_to<Control>()) {
2843
2844 Control *ctrl = canvas_item->cast_to<Control>();
2845
2846 if (key_pos)
2847 ctrl->set_pos(Point2());
2848 //if (key_scale)
2849 // AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl,"rect/size",ctrl->get_size());
2850 }
2851 }
2852
2853 } break;
2854 case VIEW_CENTER_TO_SELECTION:
2855 case VIEW_FRAME_TO_SELECTION: {
2856
2857 Vector2 center(0.f, 0.f);
2858 Rect2 rect;
2859 int count = 0;
2860
2861 Map<Node *, Object *> &selection = editor_selection->get_selection();
2862 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2863 CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
2864 if (!canvas_item) continue;
2865 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2866 continue;
2867
2868 // counting invisible items, for now
2869 //if (!canvas_item->is_visible()) continue;
2870 ++count;
2871
2872 Rect2 item_rect = canvas_item->get_item_rect();
2873
2874 Vector2 pos = canvas_item->get_global_transform().get_origin();
2875 Vector2 scale = canvas_item->get_global_transform().get_scale();
2876 real_t angle = canvas_item->get_global_transform().get_rotation();
2877
2878 Matrix32 t(angle, Vector2(0.f, 0.f));
2879 item_rect = t.xform(item_rect);
2880 Rect2 canvas_item_rect(pos + scale * item_rect.pos, scale * item_rect.size);
2881 if (count == 1) {
2882 rect = canvas_item_rect;
2883 } else {
2884 rect = rect.merge(canvas_item_rect);
2885 }
2886 };
2887 if (count == 0) break;
2888
2889 if (p_op == VIEW_CENTER_TO_SELECTION) {
2890
2891 center = rect.pos + rect.size / 2;
2892 Vector2 offset = viewport->get_size() / 2 - editor->get_scene_root()->get_global_canvas_transform().xform(center);
2893 h_scroll->set_val(h_scroll->get_val() - offset.x / zoom);
2894 v_scroll->set_val(v_scroll->get_val() - offset.y / zoom);
2895
2896 } else { // VIEW_FRAME_TO_SELECTION
2897
2898 if (rect.size.x > CMP_EPSILON && rect.size.y > CMP_EPSILON) {
2899 float scale_x = viewport->get_size().x / rect.size.x;
2900 float scale_y = viewport->get_size().y / rect.size.y;
2901 zoom = scale_x < scale_y ? scale_x : scale_y;
2902 zoom *= 0.90;
2903 _update_scroll(0);
2904 call_deferred("_popup_callback", VIEW_CENTER_TO_SELECTION);
2905 }
2906 }
2907
2908 } break;
2909 case SKELETON_MAKE_BONES: {
2910
2911 Map<Node *, Object *> &selection = editor_selection->get_selection();
2912
2913 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2914
2915 Node2D *n2d = E->key()->cast_to<Node2D>();
2916 if (!n2d)
2917 continue;
2918 if (!n2d->is_visible())
2919 continue;
2920 if (!n2d->get_parent_item())
2921 continue;
2922
2923 n2d->set_meta("_edit_bone_", true);
2924 }
2925 viewport->update();
2926
2927 } break;
2928 case SKELETON_CLEAR_BONES: {
2929
2930 Map<Node *, Object *> &selection = editor_selection->get_selection();
2931
2932 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2933
2934 Node2D *n2d = E->key()->cast_to<Node2D>();
2935 if (!n2d)
2936 continue;
2937 if (!n2d->is_visible())
2938 continue;
2939
2940 n2d->set_meta("_edit_bone_", Variant());
2941 }
2942 viewport->update();
2943
2944 } break;
2945 case SKELETON_SET_IK_CHAIN: {
2946
2947 List<Node *> &selection = editor_selection->get_selected_node_list();
2948
2949 for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
2950
2951 CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
2952 if (!canvas_item || !canvas_item->is_visible())
2953 continue;
2954
2955 if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
2956 continue;
2957
2958 canvas_item->set_meta("_edit_ik_", true);
2959 }
2960
2961 viewport->update();
2962
2963 } break;
2964 case SKELETON_CLEAR_IK_CHAIN: {
2965
2966 Map<Node *, Object *> &selection = editor_selection->get_selection();
2967
2968 for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2969
2970 CanvasItem *n2d = E->key()->cast_to<CanvasItem>();
2971 if (!n2d)
2972 continue;
2973 if (!n2d->is_visible())
2974 continue;
2975
2976 n2d->set_meta("_edit_ik_", Variant());
2977 }
2978 viewport->update();
2979
2980 } break;
2981 }
2982 }
2983 #if 0
2984 template< class P, class C > void CanvasItemEditor::space_selected_items() {
2985 P p;
2986 if ( canvas_items.size() > 2 ) {
2987 Vector< CanvasItem * > items;
2988 for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) {
2989 CanvasItem *it_curr = E->key();
2990 items.push_back( it_curr );
2991 }
2992 items.sort_custom< C >();
2993
2994 float width_s = p.get( items[0]->get_item_rect().size );
2995 float width_e = p.get( items[ items.size() - 1 ]->get_item_rect().size );
2996 float start_x = p.get( items[0]->get_global_transform().elements[2] ) + ( width_s / 2 );
2997 float end_x = p.get( items[ items.size() - 1 ]->get_global_transform().elements[2] ) + ( width_e / 2 );
2998 float sp = ( end_x - start_x ) / ( items.size() - 1 );
2999
3000 for ( int i = 0; i < items.size(); i++ ) {
3001 CanvasItem *it_curr = items[i];
3002 Vector2 v = it_curr->get_global_transform().elements[2];
3003 Rect2 r = it_curr->get_item_rect();
3004 p.set( r.pos, ( start_x + sp * i ) - ( p.get( v ) + p.get( r.size ) / 2 ) );
3005 it_curr->edit_set_rect( r );
3006 }
3007 viewport->update();
3008 }
3009 }
3010 #endif
3011
_bind_methods()3012 void CanvasItemEditor::_bind_methods() {
3013
3014 ObjectTypeDB::bind_method("_node_removed", &CanvasItemEditor::_node_removed);
3015 ObjectTypeDB::bind_method("_update_scroll", &CanvasItemEditor::_update_scroll);
3016 ObjectTypeDB::bind_method("_popup_callback", &CanvasItemEditor::_popup_callback);
3017 ObjectTypeDB::bind_method("_visibility_changed", &CanvasItemEditor::_visibility_changed);
3018 ObjectTypeDB::bind_method("_dialog_value_changed", &CanvasItemEditor::_dialog_value_changed);
3019 ObjectTypeDB::bind_method("_get_editor_data", &CanvasItemEditor::_get_editor_data);
3020 ObjectTypeDB::bind_method("_tool_select", &CanvasItemEditor::_tool_select);
3021 ObjectTypeDB::bind_method("_keying_changed", &CanvasItemEditor::_keying_changed);
3022 ObjectTypeDB::bind_method("_unhandled_key_input", &CanvasItemEditor::_unhandled_key_input);
3023 ObjectTypeDB::bind_method("_viewport_draw", &CanvasItemEditor::_viewport_draw);
3024 ObjectTypeDB::bind_method("_viewport_input_event", &CanvasItemEditor::_viewport_input_event);
3025 ObjectTypeDB::bind_method("_snap_changed", &CanvasItemEditor::_snap_changed);
3026 ObjectTypeDB::bind_method(_MD("_selection_result_pressed"), &CanvasItemEditor::_selection_result_pressed);
3027 ObjectTypeDB::bind_method(_MD("_selection_menu_hide"), &CanvasItemEditor::_selection_menu_hide);
3028
3029 ADD_SIGNAL(MethodInfo("item_lock_status_changed"));
3030 ADD_SIGNAL(MethodInfo("item_group_status_changed"));
3031 }
3032
3033 #if 0
3034 void CanvasItemEditor::end_drag() {
3035 print_line( "end drag" );
3036
3037 if (undo_redo) {
3038
3039 undo_redo->create_action("Edit CanvasItem");
3040 for(CanvasItemMap::Element *E=canvas_items.front();E;E=E->next()) {
3041 CanvasItem *canvas_item = E->key();
3042 Variant state=canvas_item->edit_get_state();
3043 undo_redo->add_do_method(canvas_item,"edit_set_state",state);
3044 undo_redo->add_undo_method(canvas_item,"edit_set_state",E->get().undo_state);
3045 }
3046 undo_redo->commit_action();
3047 }
3048
3049 drag=DRAG_NONE;
3050 viewport->update();
3051 }
3052
3053 void CanvasItemEditor::box_selection_start( Point2 &click ) {
3054 print_line( "box selection start" );
3055
3056 drag_from=transform.affine_inverse().xform(click);
3057
3058 box_selecting=true;
3059 box_selecting_to=drag_from;
3060 viewport->update();
3061 }
3062
3063 bool CanvasItemEditor::box_selection_end() {
3064 print_line( "box selection end" );
3065
3066 Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene();
3067 if (scene) {
3068
3069 List<CanvasItem*> selitems;
3070
3071 Point2 bsfrom = transform.xform(drag_from);
3072 Point2 bsto= transform.xform(box_selecting_to);
3073 if (bsfrom.x>bsto.x)
3074 SWAP(bsfrom.x,bsto.x);
3075 if (bsfrom.y>bsto.y)
3076 SWAP(bsfrom.y,bsto.y);
3077
3078 if ( bsfrom.distance_to( bsto ) < 3 ) {
3079 print_line( "box selection too small" );
3080 box_selecting=false;
3081 viewport->update();
3082 return false;
3083 }
3084
3085 _find_canvas_items_at_rect(Rect2(bsfrom,bsto-bsfrom),scene,transform,&selitems);
3086
3087 for(List<CanvasItem*>::Element *E=selitems.front();E;E=E->next()) {
3088
3089 _append_canvas_item(E->get());
3090 }
3091
3092 }
3093
3094 box_selecting=false;
3095 viewport->update();
3096
3097 return true;
3098 }
3099 #endif
3100
add_control_to_menu_panel(Control * p_control)3101 void CanvasItemEditor::add_control_to_menu_panel(Control *p_control) {
3102
3103 hb->add_child(p_control);
3104 }
3105
get_palette_split()3106 HSplitContainer *CanvasItemEditor::get_palette_split() {
3107
3108 return palette_split;
3109 }
3110
get_bottom_split()3111 VSplitContainer *CanvasItemEditor::get_bottom_split() {
3112
3113 return bottom_split;
3114 }
3115
CanvasItemEditor(EditorNode * p_editor)3116 CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
3117
3118 tool = TOOL_SELECT;
3119 undo_redo = p_editor->get_undo_redo();
3120 editor = p_editor;
3121 editor_selection = p_editor->get_editor_selection();
3122 editor_selection->add_editor_plugin(this);
3123 editor_selection->connect("selection_changed", this, "update");
3124
3125 hb = memnew(HBoxContainer);
3126 add_child(hb);
3127 hb->set_area_as_parent_rect();
3128
3129 bottom_split = memnew(VSplitContainer);
3130 bottom_split->set_v_size_flags(SIZE_EXPAND_FILL);
3131 add_child(bottom_split);
3132
3133 palette_split = memnew(HSplitContainer);
3134 palette_split->set_v_size_flags(SIZE_EXPAND_FILL);
3135 bottom_split->add_child(palette_split);
3136
3137 Control *vp_base = memnew(Control);
3138 vp_base->set_v_size_flags(SIZE_EXPAND_FILL);
3139 palette_split->add_child(vp_base);
3140
3141 Control *vp = memnew(Control);
3142 vp_base->add_child(vp);
3143 vp->set_area_as_parent_rect();
3144 vp->add_child(p_editor->get_scene_root());
3145
3146 viewport = memnew(CanvasItemEditorViewport(p_editor, this));
3147 vp_base->add_child(viewport);
3148 viewport->set_area_as_parent_rect();
3149
3150 h_scroll = memnew(HScrollBar);
3151 v_scroll = memnew(VScrollBar);
3152
3153 viewport->add_child(h_scroll);
3154 viewport->add_child(v_scroll);
3155 viewport->connect("draw", this, "_viewport_draw");
3156 viewport->connect("input_event", this, "_viewport_input_event");
3157
3158 h_scroll->connect("value_changed", this, "_update_scroll", Vector<Variant>(), true);
3159 v_scroll->connect("value_changed", this, "_update_scroll", Vector<Variant>(), true);
3160
3161 h_scroll->hide();
3162 v_scroll->hide();
3163 updating_scroll = false;
3164 viewport->set_focus_mode(FOCUS_ALL);
3165 handle_len = 10;
3166 first_update = true;
3167
3168 select_button = memnew(ToolButton);
3169 select_button->set_toggle_mode(true);
3170 hb->add_child(select_button);
3171 select_button->connect("pressed", this, "_tool_select", make_binds(TOOL_SELECT));
3172 select_button->set_pressed(true);
3173 select_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/select_mode", TTR("Select Mode"), KEY_Q));
3174 select_button->set_tooltip(TTR("Select Mode") + " $sc\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Drag: Rotate") + "\n" + TTR("Alt+Drag: Move") + "\n" + TTR("Press 'v' to Change Pivot, 'Shift+v' to Drag Pivot (while moving).") + "\n" + TTR("Alt+RMB: Depth list selection"));
3175
3176 move_button = memnew(ToolButton);
3177 move_button->set_toggle_mode(true);
3178 hb->add_child(move_button);
3179 move_button->connect("pressed", this, "_tool_select", make_binds(TOOL_MOVE));
3180 move_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/move_mode", TTR("Move Mode"), KEY_W));
3181 move_button->set_tooltip(TTR("Move Mode"));
3182
3183 rotate_button = memnew(ToolButton);
3184 rotate_button->set_toggle_mode(true);
3185 hb->add_child(rotate_button);
3186 rotate_button->connect("pressed", this, "_tool_select", make_binds(TOOL_ROTATE));
3187 rotate_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/rotate_mode", TTR("Rotate Mode"), KEY_E));
3188 rotate_button->set_tooltip(TTR("Rotate Mode"));
3189
3190 hb->add_child(memnew(VSeparator));
3191
3192 list_select_button = memnew(ToolButton);
3193 list_select_button->set_toggle_mode(true);
3194 hb->add_child(list_select_button);
3195 list_select_button->connect("pressed", this, "_tool_select", make_binds(TOOL_LIST_SELECT));
3196 list_select_button->set_tooltip(TTR("Show a list of all objects at the position clicked\n(same as Alt+RMB in select mode)."));
3197
3198 pivot_button = memnew(ToolButton);
3199 pivot_button->set_toggle_mode(true);
3200 hb->add_child(pivot_button);
3201 pivot_button->connect("pressed", this, "_tool_select", make_binds(TOOL_EDIT_PIVOT));
3202 pivot_button->set_tooltip(TTR("Click to change object's rotation pivot."));
3203
3204 pan_button = memnew(ToolButton);
3205 pan_button->set_toggle_mode(true);
3206 hb->add_child(pan_button);
3207 pan_button->connect("pressed", this, "_tool_select", make_binds(TOOL_PAN));
3208 pan_button->set_tooltip(TTR("Pan Mode"));
3209
3210 hb->add_child(memnew(VSeparator));
3211
3212 lock_button = memnew(ToolButton);
3213 hb->add_child(lock_button);
3214
3215 lock_button->connect("pressed", this, "_popup_callback", varray(LOCK_SELECTED));
3216 lock_button->set_tooltip(TTR("Lock the selected object in place (can't be moved)."));
3217
3218 unlock_button = memnew(ToolButton);
3219 hb->add_child(unlock_button);
3220 unlock_button->connect("pressed", this, "_popup_callback", varray(UNLOCK_SELECTED));
3221 unlock_button->set_tooltip(TTR("Unlock the selected object (can be moved)."));
3222
3223 group_button = memnew(ToolButton);
3224 hb->add_child(group_button);
3225 group_button->connect("pressed", this, "_popup_callback", varray(GROUP_SELECTED));
3226 group_button->set_tooltip(TTR("Makes sure the object's children are not selectable."));
3227
3228 ungroup_button = memnew(ToolButton);
3229 hb->add_child(ungroup_button);
3230 ungroup_button->connect("pressed", this, "_popup_callback", varray(UNGROUP_SELECTED));
3231 ungroup_button->set_tooltip(TTR("Restores the object's children's ability to be selected."));
3232
3233 hb->add_child(memnew(VSeparator));
3234
3235 edit_menu = memnew(MenuButton);
3236 edit_menu->set_text(TTR("Edit"));
3237 hb->add_child(edit_menu);
3238 edit_menu->get_popup()->connect("item_pressed", this, "_popup_callback");
3239
3240 PopupMenu *p;
3241 p = edit_menu->get_popup();
3242 p->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/use_snap", TTR("Use Snap")), SNAP_USE);
3243 p->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/show_grid", TTR("Show Grid")), SNAP_SHOW_GRID);
3244 p->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/use_rotation_snap", TTR("Use Rotation Snap")), SNAP_USE_ROTATION);
3245 p->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/snap_relative", TTR("Snap Relative")), SNAP_RELATIVE);
3246 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/configure_snap", TTR("Configure Snap..")), SNAP_CONFIGURE);
3247 p->add_separator();
3248 p->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/use_pixel_snap", TTR("Use Pixel Snap")), SNAP_USE_PIXEL);
3249 p->add_separator();
3250 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/expand_to_parent", TTR("Expand to Parent"), KEY_MASK_CMD | KEY_P), EXPAND_TO_PARENT);
3251 p->add_separator();
3252 p->add_submenu_item(TTR("Skeleton.."), "skeleton");
3253 PopupMenu *p2 = memnew(PopupMenu);
3254 p->add_child(p2);
3255 p2->set_name("skeleton");
3256 p2->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_make_bones", TTR("Make Bones"), KEY_MASK_CMD | KEY_MASK_SHIFT | KEY_B), SKELETON_MAKE_BONES);
3257 p2->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_clear_bones", TTR("Clear Bones")), SKELETON_CLEAR_BONES);
3258 p2->add_separator();
3259 p2->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_set_ik_chain", TTR("Make IK Chain")), SKELETON_SET_IK_CHAIN);
3260 p2->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_clear_ik_chain", TTR("Clear IK Chain")), SKELETON_CLEAR_IK_CHAIN);
3261 p2->connect("item_pressed", this, "_popup_callback");
3262
3263 /*
3264 p->add_item("Align Horizontal",ALIGN_HORIZONTAL);
3265 p->add_item("Align Vertical",ALIGN_VERTICAL);
3266 p->add_item("Space Horizontal",SPACE_HORIZONTAL);
3267 p->add_item("Space Vertical",SPACE_VERTICAL);*/
3268
3269 view_menu = memnew(MenuButton);
3270 view_menu->set_text(TTR("View"));
3271 hb->add_child(view_menu);
3272 view_menu->get_popup()->connect("item_pressed", this, "_popup_callback");
3273
3274 p = view_menu->get_popup();
3275
3276 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_in", TTR("Zoom In")), ZOOM_IN);
3277 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_out", TTR("Zoom Out")), ZOOM_OUT);
3278 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_reset", TTR("Zoom Reset")), ZOOM_RESET);
3279 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_set", TTR("Zoom Set..")), ZOOM_SET);
3280 p->add_separator();
3281 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/center_selection", TTR("Center Selection"), KEY_F), VIEW_CENTER_TO_SELECTION);
3282 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/frame_selection", TTR("Frame Selection"), KEY_MASK_SHIFT | KEY_F), VIEW_FRAME_TO_SELECTION);
3283
3284 anchor_menu = memnew(MenuButton);
3285 anchor_menu->set_text(TTR("Anchor"));
3286 hb->add_child(anchor_menu);
3287 anchor_menu->get_popup()->connect("item_pressed", this, "_popup_callback");
3288 anchor_menu->hide();
3289
3290 //p = anchor_menu->get_popup();
3291
3292 animation_hb = memnew(HBoxContainer);
3293 hb->add_child(animation_hb);
3294 animation_hb->add_child(memnew(VSeparator));
3295 animation_hb->hide();
3296
3297 key_loc_button = memnew(Button("loc"));
3298 key_loc_button->set_toggle_mode(true);
3299 key_loc_button->set_pressed(true);
3300 key_loc_button->set_focus_mode(FOCUS_NONE);
3301 key_loc_button->add_color_override("font_color", Color(1, 0.6, 0.6));
3302 key_loc_button->add_color_override("font_color_pressed", Color(0.6, 1, 0.6));
3303 key_loc_button->connect("pressed", this, "_popup_callback", varray(ANIM_INSERT_POS));
3304 animation_hb->add_child(key_loc_button);
3305 key_rot_button = memnew(Button("rot"));
3306 key_rot_button->set_toggle_mode(true);
3307 key_rot_button->set_pressed(true);
3308 key_rot_button->set_focus_mode(FOCUS_NONE);
3309 key_rot_button->add_color_override("font_color", Color(1, 0.6, 0.6));
3310 key_rot_button->add_color_override("font_color_pressed", Color(0.6, 1, 0.6));
3311 key_rot_button->connect("pressed", this, "_popup_callback", varray(ANIM_INSERT_ROT));
3312 animation_hb->add_child(key_rot_button);
3313 key_scale_button = memnew(Button("scl"));
3314 key_scale_button->set_toggle_mode(true);
3315 key_scale_button->set_focus_mode(FOCUS_NONE);
3316 key_scale_button->add_color_override("font_color", Color(1, 0.6, 0.6));
3317 key_scale_button->add_color_override("font_color_pressed", Color(0.6, 1, 0.6));
3318 key_scale_button->connect("pressed", this, "_popup_callback", varray(ANIM_INSERT_SCALE));
3319 animation_hb->add_child(key_scale_button);
3320 key_insert_button = memnew(Button);
3321 key_insert_button->set_focus_mode(FOCUS_NONE);
3322 key_insert_button->connect("pressed", this, "_popup_callback", varray(ANIM_INSERT_KEY));
3323 key_insert_button->set_tooltip(TTR("Insert Keys"));
3324 key_insert_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key", TTR("Insert Key"), KEY_INSERT));
3325
3326 animation_hb->add_child(key_insert_button);
3327
3328 animation_menu = memnew(MenuButton);
3329 animation_menu->set_text(TTR("Animation"));
3330 animation_hb->add_child(animation_menu);
3331 animation_menu->get_popup()->connect("item_pressed", this, "_popup_callback");
3332
3333 p = animation_menu->get_popup();
3334
3335 p->add_shortcut(ED_GET_SHORTCUT("canvas_item_editor/anim_insert_key"), ANIM_INSERT_KEY);
3336 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key_existing_tracks", TTR("Insert Key (Existing Tracks)"), KEY_MASK_CMD + KEY_INSERT), ANIM_INSERT_KEY_EXISTING);
3337 p->add_separator();
3338 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_copy_pose", TTR("Copy Pose")), ANIM_COPY_POSE);
3339 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_paste_pose", TTR("Paste Pose")), ANIM_PASTE_POSE);
3340 p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_clear_pose", TTR("Clear Pose"), KEY_MASK_SHIFT | KEY_K), ANIM_CLEAR_POSE);
3341
3342 snap_dialog = memnew(SnapDialog);
3343 snap_dialog->connect("confirmed", this, "_snap_changed");
3344 add_child(snap_dialog);
3345
3346 value_dialog = memnew(AcceptDialog);
3347 value_dialog->set_title(TTR("Set a Value"));
3348 value_dialog->get_ok()->set_text(TTR("Close"));
3349 add_child(value_dialog);
3350
3351 Label *l = memnew(Label);
3352 l->set_text(TTR("Snap (Pixels):"));
3353 l->set_pos(Point2(5, 5));
3354 value_dialog->add_child(l);
3355 dialog_label = l;
3356
3357 dialog_val = memnew(SpinBox);
3358 dialog_val->set_anchor(MARGIN_RIGHT, ANCHOR_END);
3359 dialog_val->set_begin(Point2(15, 25));
3360 dialog_val->set_end(Point2(10, 25));
3361 value_dialog->add_child(dialog_val);
3362 dialog_val->connect("value_changed", this, "_dialog_value_changed");
3363 select_sb = Ref<StyleBoxTexture>(memnew(StyleBoxTexture));
3364
3365 selection_menu = memnew(PopupMenu);
3366 add_child(selection_menu);
3367 selection_menu->set_custom_minimum_size(Vector2(100, 0));
3368 selection_menu->connect("item_pressed", this, "_selection_result_pressed");
3369 selection_menu->connect("popup_hide", this, "_selection_menu_hide");
3370
3371 key_pos = true;
3372 key_rot = true;
3373 key_scale = false;
3374
3375 zoom = 1;
3376 snap_offset = Vector2(0, 0);
3377 snap_step = Vector2(10, 10);
3378 snap_rotation_offset = 0;
3379 snap_rotation_step = 15 / (180 / Math_PI);
3380 snap_grid = false;
3381 snap_show_grid = false;
3382 snap_rotation = false;
3383 snap_pixel = false;
3384 updating_value_dialog = false;
3385 box_selecting = false;
3386 //zoom=0.5;
3387 singleton = this;
3388
3389 set_process_unhandled_key_input(true);
3390 can_move_pivot = false;
3391 drag = DRAG_NONE;
3392 bone_last_frame = 0;
3393 additive_selection = false;
3394 }
3395
3396 CanvasItemEditor *CanvasItemEditor::singleton = NULL;
3397
edit(Object * p_object)3398 void CanvasItemEditorPlugin::edit(Object *p_object) {
3399
3400 canvas_item_editor->set_undo_redo(&get_undo_redo());
3401 canvas_item_editor->edit(p_object->cast_to<CanvasItem>());
3402 }
3403
handles(Object * p_object) const3404 bool CanvasItemEditorPlugin::handles(Object *p_object) const {
3405
3406 return p_object->is_type("CanvasItem");
3407 }
3408
make_visible(bool p_visible)3409 void CanvasItemEditorPlugin::make_visible(bool p_visible) {
3410
3411 if (p_visible) {
3412 canvas_item_editor->show();
3413 canvas_item_editor->set_fixed_process(true);
3414 VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport(), false);
3415 canvas_item_editor->viewport->grab_focus();
3416
3417 } else {
3418
3419 canvas_item_editor->hide();
3420 canvas_item_editor->set_fixed_process(false);
3421 VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport(), true);
3422 }
3423 }
3424
get_state() const3425 Dictionary CanvasItemEditorPlugin::get_state() const {
3426
3427 return canvas_item_editor->get_state();
3428 }
set_state(const Dictionary & p_state)3429 void CanvasItemEditorPlugin::set_state(const Dictionary &p_state) {
3430
3431 canvas_item_editor->set_state(p_state);
3432 }
3433
CanvasItemEditorPlugin(EditorNode * p_node)3434 CanvasItemEditorPlugin::CanvasItemEditorPlugin(EditorNode *p_node) {
3435
3436 editor = p_node;
3437 canvas_item_editor = memnew(CanvasItemEditor(editor));
3438 canvas_item_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
3439 editor->get_viewport()->add_child(canvas_item_editor);
3440 canvas_item_editor->set_area_as_parent_rect();
3441 canvas_item_editor->hide();
3442 }
3443
~CanvasItemEditorPlugin()3444 CanvasItemEditorPlugin::~CanvasItemEditorPlugin() {
3445 }
3446
_on_mouse_exit()3447 void CanvasItemEditorViewport::_on_mouse_exit() {
3448 if (selector->is_hidden()) {
3449 _remove_preview();
3450 }
3451 }
3452
_on_select_type(Object * selected)3453 void CanvasItemEditorViewport::_on_select_type(Object *selected) {
3454 CheckBox *check = selected->cast_to<CheckBox>();
3455 String type = check->get_text();
3456 selector_label->set_text(vformat(TTR("Add %s"), type));
3457 label->set_text(vformat(TTR("Adding %s..."), type));
3458 }
3459
_on_change_type()3460 void CanvasItemEditorViewport::_on_change_type() {
3461 CheckBox *check = btn_group->get_pressed_button()->cast_to<CheckBox>();
3462 default_type = check->get_text();
3463 _perform_drop_data();
3464 selector->hide();
3465 }
3466
_create_preview(const Vector<String> & files) const3467 void CanvasItemEditorViewport::_create_preview(const Vector<String> &files) const {
3468 label->set_pos(get_global_pos() + Point2(14, 14));
3469 label_desc->set_pos(label->get_pos() + Point2(0, label->get_size().height));
3470 for (int i = 0; i < files.size(); i++) {
3471 String path = files[i];
3472 RES res = ResourceLoader::load(path);
3473 String type = res->get_type();
3474 if (type == "ImageTexture" || type == "PackedScene") {
3475 if (type == "ImageTexture") {
3476 Ref<ImageTexture> texture = Ref<ImageTexture>(ResourceCache::get(path)->cast_to<ImageTexture>());
3477 Sprite *sprite = memnew(Sprite);
3478 sprite->set_texture(texture);
3479 sprite->set_opacity(0.7f);
3480 preview->add_child(sprite);
3481 label->show();
3482 label_desc->show();
3483 } else if (type == "PackedScene") {
3484 Ref<PackedScene> scn = ResourceLoader::load(path);
3485 if (scn.is_valid()) {
3486 Node *instance = scn->instance();
3487 if (instance) {
3488 preview->add_child(instance);
3489 }
3490 }
3491 }
3492 editor->get_scene_root()->add_child(preview);
3493 }
3494 }
3495 }
3496
_remove_preview()3497 void CanvasItemEditorViewport::_remove_preview() {
3498 if (preview->get_parent()) {
3499 editor->get_scene_root()->remove_child(preview);
3500 for (int i = preview->get_child_count() - 1; i >= 0; i--) {
3501 Node *node = preview->get_child(i);
3502 memdelete(node);
3503 }
3504 label->hide();
3505 label_desc->hide();
3506 }
3507 }
3508
_cyclical_dependency_exists(const String & p_target_scene_path,Node * p_desired_node)3509 bool CanvasItemEditorViewport::_cyclical_dependency_exists(const String &p_target_scene_path, Node *p_desired_node) {
3510 if (p_desired_node->get_filename() == p_target_scene_path) {
3511 return true;
3512 }
3513
3514 int childCount = p_desired_node->get_child_count();
3515 for (int i = 0; i < childCount; i++) {
3516 Node *child = p_desired_node->get_child(i);
3517 if (_cyclical_dependency_exists(p_target_scene_path, child)) {
3518 return true;
3519 }
3520 }
3521 return false;
3522 }
3523
_create_nodes(Node * parent,Node * child,String & path,const Point2 & p_point)3524 void CanvasItemEditorViewport::_create_nodes(Node *parent, Node *child, String &path, const Point2 &p_point) {
3525 child->set_name(path.get_file().basename());
3526 Ref<ImageTexture> texture = Ref<ImageTexture>(ResourceCache::get(path)->cast_to<ImageTexture>());
3527 Size2 texture_size = texture->get_size();
3528
3529 editor_data->get_undo_redo().add_do_method(parent, "add_child", child);
3530 editor_data->get_undo_redo().add_do_method(child, "set_owner", editor->get_edited_scene());
3531 editor_data->get_undo_redo().add_do_reference(child);
3532 editor_data->get_undo_redo().add_undo_method(parent, "remove_child", child);
3533
3534 String new_name = parent->validate_child_name(child->get_name());
3535 ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
3536 editor_data->get_undo_redo().add_do_method(sed, "live_debug_create_node", editor->get_edited_scene()->get_path_to(parent), child->get_type(), new_name);
3537 editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(editor->get_edited_scene()->get_path_to(parent)) + "/" + new_name));
3538
3539 // handle with different property for texture
3540 String property = "texture";
3541 List<PropertyInfo> props;
3542 child->get_property_list(&props);
3543 for (const List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
3544 if (E->get().name == "config/texture") { // Particles2D
3545 property = "config/texture";
3546 break;
3547 } else if (E->get().name == "texture/texture") { // Polygon2D
3548 property = "texture/texture";
3549 break;
3550 } else if (E->get().name == "normal") { // TouchScreenButton
3551 property = "normal";
3552 break;
3553 }
3554 }
3555 editor_data->get_undo_redo().add_do_property(child, property, texture);
3556
3557 // make visible for certain node type
3558 if (default_type == "Patch9Frame") {
3559 editor_data->get_undo_redo().add_do_property(child, "rect/size", texture_size);
3560 } else if (default_type == "Polygon2D") {
3561 DVector<Vector2> list;
3562 list.push_back(Vector2(0, 0));
3563 list.push_back(Vector2(texture_size.width, 0));
3564 list.push_back(Vector2(texture_size.width, texture_size.height));
3565 list.push_back(Vector2(0, texture_size.height));
3566 editor_data->get_undo_redo().add_do_property(child, "polygon", list);
3567 }
3568
3569 // locate at preview position
3570 Point2 pos;
3571 if (parent->has_method("get_global_pos")) {
3572 pos = parent->call("get_global_pos");
3573 }
3574 Matrix32 trans = canvas->get_canvas_transform();
3575 Point2 target_pos = (p_point - trans.get_origin()) / trans.get_scale().x - pos;
3576 if (default_type == "Polygon2D" || default_type == "TouchScreenButton" || default_type == "TextureFrame" || default_type == "Patch9Frame") {
3577 target_pos -= texture_size / 2;
3578 }
3579 // there's nothing to be used as source position so snapping will work as absolute if enabled
3580 target_pos = canvas->snap_point(target_pos, Vector2());
3581 editor_data->get_undo_redo().add_do_method(child, "set_pos", target_pos);
3582 }
3583
_create_instance(Node * parent,String & path,const Point2 & p_point)3584 bool CanvasItemEditorViewport::_create_instance(Node *parent, String &path, const Point2 &p_point) {
3585 Ref<PackedScene> sdata = ResourceLoader::load(path);
3586 if (!sdata.is_valid()) { // invalid scene
3587 return false;
3588 }
3589
3590 Node *instanced_scene = sdata->instance(true);
3591 if (!instanced_scene) { // error on instancing
3592 return false;
3593 }
3594
3595 if (editor->get_edited_scene()->get_filename() != "") { // cyclical instancing
3596 if (_cyclical_dependency_exists(editor->get_edited_scene()->get_filename(), instanced_scene)) {
3597 memdelete(instanced_scene);
3598 return false;
3599 }
3600 }
3601
3602 instanced_scene->set_filename(Globals::get_singleton()->localize_path(path));
3603
3604 editor_data->get_undo_redo().add_do_method(parent, "add_child", instanced_scene);
3605 editor_data->get_undo_redo().add_do_method(instanced_scene, "set_owner", editor->get_edited_scene());
3606 editor_data->get_undo_redo().add_do_reference(instanced_scene);
3607 editor_data->get_undo_redo().add_undo_method(parent, "remove_child", instanced_scene);
3608
3609 String new_name = parent->validate_child_name(instanced_scene->get_name());
3610 ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
3611 editor_data->get_undo_redo().add_do_method(sed, "live_debug_instance_node", editor->get_edited_scene()->get_path_to(parent), path, new_name);
3612 editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(editor->get_edited_scene()->get_path_to(parent)) + "/" + new_name));
3613
3614 Point2 pos;
3615 Node2D *parent_node2d = parent->cast_to<Node2D>();
3616 if (parent_node2d) {
3617 pos = parent_node2d->get_global_pos();
3618 } else {
3619 Control *parent_control = parent->cast_to<Control>();
3620 if (parent_control) {
3621 pos = parent_control->get_global_pos();
3622 }
3623 }
3624 Matrix32 trans = canvas->get_canvas_transform();
3625 Vector2 target_pos = (p_point - trans.get_origin()) / trans.get_scale().x - pos;
3626 // in relative snapping it may be useful for the user to take the original node position into account
3627 Vector2 start_pos = instanced_scene->cast_to<Node2D>() ? instanced_scene->cast_to<Node2D>()->get_pos() : target_pos;
3628 target_pos = canvas->snap_point(target_pos, start_pos);
3629 editor_data->get_undo_redo().add_do_method(instanced_scene, "set_pos", target_pos);
3630
3631 return true;
3632 }
3633
_perform_drop_data()3634 void CanvasItemEditorViewport::_perform_drop_data() {
3635 _remove_preview();
3636
3637 Vector<String> error_files;
3638
3639 editor_data->get_undo_redo().create_action(TTR("Create Node"));
3640
3641 for (int i = 0; i < selected_files.size(); i++) {
3642 String path = selected_files[i];
3643 RES res = ResourceLoader::load(path);
3644 if (res.is_null()) {
3645 continue;
3646 }
3647 String type = res->get_type();
3648 if (type == "ImageTexture") {
3649 Node *child;
3650 if (default_type == "Light2D")
3651 child = memnew(Light2D);
3652 else if (default_type == "Particles2D")
3653 child = memnew(Particles2D);
3654 else if (default_type == "Polygon2D")
3655 child = memnew(Polygon2D);
3656 else if (default_type == "TouchScreenButton")
3657 child = memnew(TouchScreenButton);
3658 else if (default_type == "TextureFrame")
3659 child = memnew(TextureFrame);
3660 else if (default_type == "Patch9Frame")
3661 child = memnew(Patch9Frame);
3662 else
3663 child = memnew(Sprite); // default
3664
3665 _create_nodes(target_node, child, path, drop_pos);
3666 } else if (type == "PackedScene") {
3667 bool success = _create_instance(target_node, path, drop_pos);
3668 if (!success) {
3669 error_files.push_back(path);
3670 }
3671 }
3672 }
3673
3674 editor_data->get_undo_redo().commit_action();
3675
3676 if (error_files.size() > 0) {
3677 String files_str;
3678 for (int i = 0; i < error_files.size(); i++) {
3679 files_str += error_files[i].get_file().basename() + ",";
3680 }
3681 files_str = files_str.substr(0, files_str.length() - 1);
3682 accept->get_ok()->set_text(TTR("Ugh"));
3683 accept->set_text(vformat(TTR("Error instancing scene from %s"), files_str.c_str()));
3684 accept->popup_centered_minsize();
3685 }
3686 }
3687
can_drop_data(const Point2 & p_point,const Variant & p_data) const3688 bool CanvasItemEditorViewport::can_drop_data(const Point2 &p_point, const Variant &p_data) const {
3689 Dictionary d = p_data;
3690 if (d.has("type")) {
3691 if (String(d["type"]) == "files") {
3692 Vector<String> files = d["files"];
3693 bool can_instance = false;
3694 for (int i = 0; i < files.size(); i++) { // check if dragged files contain resource or scene can be created at least one
3695 RES res = ResourceLoader::load(files[i]);
3696 if (res.is_null()) {
3697 continue;
3698 }
3699 String type = res->get_type();
3700 if (type == "PackedScene") {
3701 Ref<PackedScene> sdata = ResourceLoader::load(files[i]);
3702 Node *instanced_scene = sdata->instance(true);
3703 if (!instanced_scene) {
3704 continue;
3705 }
3706 memdelete(instanced_scene);
3707 }
3708 can_instance = true;
3709 break;
3710 }
3711 if (can_instance) {
3712 if (!preview->get_parent()) { // create preview only once
3713 _create_preview(files);
3714 }
3715 Matrix32 trans = canvas->get_canvas_transform();
3716 preview->set_pos((p_point - trans.get_origin()) / trans.get_scale().x);
3717 label->set_text(vformat(TTR("Adding %s..."), default_type));
3718 }
3719 return can_instance;
3720 }
3721 }
3722 label->hide();
3723 return false;
3724 }
3725
drop_data(const Point2 & p_point,const Variant & p_data)3726 void CanvasItemEditorViewport::drop_data(const Point2 &p_point, const Variant &p_data) {
3727 bool is_shift = Input::get_singleton()->is_key_pressed(KEY_SHIFT);
3728 bool is_alt = Input::get_singleton()->is_key_pressed(KEY_ALT);
3729
3730 selected_files.clear();
3731 Dictionary d = p_data;
3732 if (d.has("type") && String(d["type"]) == "files") {
3733 selected_files = d["files"];
3734 }
3735
3736 List<Node *> list = editor->get_editor_selection()->get_selected_node_list();
3737 if (list.size() == 0) {
3738 accept->get_ok()->set_text(TTR("OK :("));
3739 accept->set_text(TTR("No parent to instance a child at."));
3740 accept->popup_centered_minsize();
3741 _remove_preview();
3742 return;
3743 }
3744 if (list.size() != 1) {
3745 accept->get_ok()->set_text(TTR("I see.."));
3746 accept->set_text(TTR("This operation requires a single selected node."));
3747 accept->popup_centered_minsize();
3748 _remove_preview();
3749 return;
3750 }
3751
3752 target_node = list[0];
3753 if (is_shift && target_node != editor->get_edited_scene()) {
3754 target_node = target_node->get_parent();
3755 }
3756 drop_pos = p_point;
3757
3758 if (is_alt) {
3759 List<BaseButton *> btn_list;
3760 btn_group->get_button_list(&btn_list);
3761 for (int i = 0; i < btn_list.size(); i++) {
3762 CheckBox *check = btn_list[i]->cast_to<CheckBox>();
3763 check->set_pressed(check->get_text() == default_type);
3764 }
3765 selector_label->set_text(vformat(TTR("Add %s"), default_type));
3766 selector->popup_centered_minsize();
3767 } else {
3768 _perform_drop_data();
3769 }
3770 }
3771
_notification(int p_what)3772 void CanvasItemEditorViewport::_notification(int p_what) {
3773 if (p_what == NOTIFICATION_ENTER_TREE) {
3774 connect("mouse_exit", this, "_on_mouse_exit");
3775 } else if (p_what == NOTIFICATION_EXIT_TREE) {
3776 disconnect("mouse_exit", this, "_on_mouse_exit");
3777 }
3778 }
3779
_bind_methods()3780 void CanvasItemEditorViewport::_bind_methods() {
3781 ObjectTypeDB::bind_method(_MD("_on_select_type"), &CanvasItemEditorViewport::_on_select_type);
3782 ObjectTypeDB::bind_method(_MD("_on_change_type"), &CanvasItemEditorViewport::_on_change_type);
3783 ObjectTypeDB::bind_method(_MD("_on_mouse_exit"), &CanvasItemEditorViewport::_on_mouse_exit);
3784 }
3785
CanvasItemEditorViewport(EditorNode * p_node,CanvasItemEditor * p_canvas)3786 CanvasItemEditorViewport::CanvasItemEditorViewport(EditorNode *p_node, CanvasItemEditor *p_canvas) {
3787 default_type = "Sprite";
3788 // Node2D
3789 types.push_back("Sprite");
3790 types.push_back("Light2D");
3791 types.push_back("Particles2D");
3792 types.push_back("Polygon2D");
3793 types.push_back("TouchScreenButton");
3794 // Control
3795 types.push_back("TextureFrame");
3796 types.push_back("Patch9Frame");
3797
3798 target_node = NULL;
3799 editor = p_node;
3800 editor_data = editor->get_scene_tree_dock()->get_editor_data();
3801 canvas = p_canvas;
3802 preview = memnew(Node2D);
3803 accept = memnew(AcceptDialog);
3804 editor->get_gui_base()->add_child(accept);
3805
3806 selector = memnew(WindowDialog);
3807 selector->set_title(TTR("Change default type"));
3808
3809 VBoxContainer *vbc = memnew(VBoxContainer);
3810 vbc->add_constant_override("separation", 10 * EDSCALE);
3811 vbc->set_custom_minimum_size(Size2(200, 260) * EDSCALE);
3812
3813 selector_label = memnew(Label);
3814 selector_label->set_align(Label::ALIGN_CENTER);
3815 selector_label->set_valign(Label::VALIGN_BOTTOM);
3816 selector_label->set_custom_minimum_size(Size2(0, 30) * EDSCALE);
3817 vbc->add_child(selector_label);
3818
3819 btn_group = memnew(ButtonGroup);
3820 btn_group->set_h_size_flags(0);
3821 btn_group->connect("button_selected", this, "_on_select_type");
3822
3823 for (int i = 0; i < types.size(); i++) {
3824 CheckBox *check = memnew(CheckBox);
3825 check->set_text(types[i]);
3826 btn_group->add_child(check);
3827 }
3828 vbc->add_child(btn_group);
3829
3830 Button *ok = memnew(Button);
3831 ok->set_text(TTR("OK"));
3832 ok->set_h_size_flags(0);
3833 vbc->add_child(ok);
3834 ok->connect("pressed", this, "_on_change_type");
3835
3836 selector->add_child(vbc);
3837 editor->get_gui_base()->add_child(selector);
3838
3839 label = memnew(Label);
3840 label->add_color_override("font_color", Color(1, 1, 0, 1));
3841 label->add_color_override("font_color_shadow", Color(0, 0, 0, 1));
3842 label->add_constant_override("shadow_as_outline", 1 * EDSCALE);
3843 label->hide();
3844 editor->get_gui_base()->add_child(label);
3845
3846 label_desc = memnew(Label);
3847 label_desc->set_text(TTR("Drag & drop + Shift : Add node as sibling\nDrag & drop + Alt : Change node type"));
3848 label_desc->add_color_override("font_color", Color(0.6, 0.6, 0.6, 1));
3849 label_desc->add_color_override("font_color_shadow", Color(0.2, 0.2, 0.2, 1));
3850 label_desc->add_constant_override("shadow_as_outline", 1 * EDSCALE);
3851 label_desc->add_constant_override("line_spacing", 0);
3852 label_desc->hide();
3853 editor->get_gui_base()->add_child(label_desc);
3854 }
3855