1 /*************************************************************************/
2 /* path_2d_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 "path_2d_editor_plugin.h"
31
32 #include "canvas_item_editor_plugin.h"
33 #include "editor/editor_settings.h"
34 #include "os/file_access.h"
35 #include "os/keyboard.h"
_notification(int p_what)36 void Path2DEditor::_notification(int p_what) {
37
38 switch (p_what) {
39
40 case NOTIFICATION_READY: {
41
42 // button_create->set_icon( get_icon("Edit","EditorIcons"));
43 //button_edit->set_icon( get_icon("MovePoint","EditorIcons"));
44 //set_pressed_button(button_edit);
45 //button_edit->set_pressed(true);
46
47 } break;
48 case NOTIFICATION_FIXED_PROCESS: {
49
50 } break;
51 }
52 }
_node_removed(Node * p_node)53 void Path2DEditor::_node_removed(Node *p_node) {
54
55 if (p_node == node) {
56 node = NULL;
57 hide();
58 }
59 }
60
forward_input_event(const InputEvent & p_event)61 bool Path2DEditor::forward_input_event(const InputEvent &p_event) {
62
63 if (!node)
64 return false;
65
66 if (!node->is_visible())
67 return false;
68
69 if (!node->get_curve().is_valid())
70 return false;
71
72 switch (p_event.type) {
73
74 case InputEvent::MOUSE_BUTTON: {
75
76 const InputEventMouseButton &mb = p_event.mouse_button;
77
78 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
79
80 Vector2 gpoint = Point2(mb.x, mb.y);
81 Vector2 cpoint = !mb.mod.alt ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint)));
82
83 //first check if a point is to be added (segment split)
84 real_t grab_treshold = EDITOR_DEF("poly_editor/point_grab_radius", 8);
85
86 // Test move point!!
87
88 if (mb.pressed && action == ACTION_NONE) {
89
90 Ref<Curve2D> curve = node->get_curve();
91
92 for (int i = 0; i < curve->get_point_count(); i++) {
93
94 bool pointunder = false;
95
96 {
97 Point2 p = xform.xform(curve->get_point_pos(i));
98 if (gpoint.distance_to(p) < grab_treshold) {
99
100 if (mb.button_index == BUTTON_LEFT && !mb.mod.shift && mode == MODE_EDIT) {
101
102 action = ACTION_MOVING_POINT;
103 action_point = i;
104 moving_from = curve->get_point_pos(i);
105 moving_screen_from = gpoint;
106 return true;
107 } else if ((mb.button_index == BUTTON_RIGHT && mode == MODE_EDIT) || (mb.button_index == BUTTON_LEFT && mode == MODE_DELETE)) {
108
109 undo_redo->create_action(TTR("Remove Point from Curve"));
110 undo_redo->add_do_method(curve.ptr(), "remove_point", i);
111 undo_redo->add_undo_method(curve.ptr(), "add_point", curve->get_point_pos(i), curve->get_point_in(i), curve->get_point_out(i), i);
112 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
113 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
114 undo_redo->commit_action();
115 return true;
116 } else
117 pointunder = true;
118 }
119 }
120
121 if (mb.button_index == BUTTON_LEFT && i < (curve->get_point_count() - 1)) {
122 Point2 p = xform.xform(curve->get_point_pos(i) + curve->get_point_out(i));
123 if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) {
124
125 action = ACTION_MOVING_OUT;
126 action_point = i;
127 moving_from = curve->get_point_out(i);
128 moving_screen_from = gpoint;
129 return true;
130 }
131 }
132
133 if (mb.button_index == BUTTON_LEFT && i > 0) {
134 Point2 p = xform.xform(curve->get_point_pos(i) + curve->get_point_in(i));
135 if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) {
136
137 action = ACTION_MOVING_IN;
138 action_point = i;
139 moving_from = curve->get_point_in(i);
140 moving_screen_from = gpoint;
141 return true;
142 }
143 }
144
145 if (pointunder)
146 return true;
147 }
148 }
149
150 // Test add point in empty space!
151
152 if (mb.pressed && mb.button_index == BUTTON_LEFT && ((mb.mod.command && mode == MODE_EDIT) || mode == MODE_CREATE)) {
153
154 Ref<Curve2D> curve = node->get_curve();
155
156 undo_redo->create_action(TTR("Add Point to Curve"));
157 undo_redo->add_do_method(curve.ptr(), "add_point", cpoint);
158 undo_redo->add_undo_method(curve.ptr(), "remove_point", curve->get_point_count());
159 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
160 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
161 undo_redo->commit_action();
162
163 action = ACTION_MOVING_POINT;
164 action_point = curve->get_point_count() - 1;
165 moving_from = curve->get_point_pos(action_point);
166 moving_screen_from = gpoint;
167
168 canvas_item_editor->get_viewport_control()->update();
169
170 return true;
171 }
172
173 if (!mb.pressed && mb.button_index == BUTTON_LEFT && action != ACTION_NONE) {
174
175 Ref<Curve2D> curve = node->get_curve();
176
177 Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from);
178 switch (action) {
179
180 case ACTION_MOVING_POINT: {
181
182 undo_redo->create_action(TTR("Move Point in Curve"));
183 undo_redo->add_do_method(curve.ptr(), "set_point_pos", action_point, cpoint);
184 undo_redo->add_undo_method(curve.ptr(), "set_point_pos", action_point, moving_from);
185 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
186 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
187 undo_redo->commit_action();
188
189 } break;
190 case ACTION_MOVING_IN: {
191
192 undo_redo->create_action(TTR("Move In-Control in Curve"));
193 undo_redo->add_do_method(curve.ptr(), "set_point_in", action_point, new_pos);
194 undo_redo->add_undo_method(curve.ptr(), "set_point_in", action_point, moving_from);
195 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
196 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
197 undo_redo->commit_action();
198
199 } break;
200 case ACTION_MOVING_OUT: {
201
202 undo_redo->create_action(TTR("Move Out-Control in Curve"));
203 undo_redo->add_do_method(curve.ptr(), "set_point_out", action_point, new_pos);
204 undo_redo->add_undo_method(curve.ptr(), "set_point_out", action_point, moving_from);
205 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
206 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
207 undo_redo->commit_action();
208
209 } break;
210 }
211
212 action = ACTION_NONE;
213
214 return true;
215 }
216
217 #if 0
218 switch(mode) {
219
220
221 case MODE_CREATE: {
222
223 if (mb.button_index==BUTTON_LEFT && mb.pressed) {
224
225
226 if (!wip_active) {
227
228 wip.clear();
229 wip.push_back( canvas_item_editor->snap_point(cpoint) );
230 wip_active=true;
231 edited_point_pos=canvas_item_editor->snap_point(cpoint);
232 canvas_item_editor->update();
233 edited_point=1;
234 return true;
235 } else {
236
237 if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) {
238 //wip closed
239 _wip_close();
240
241 return true;
242 } else {
243
244 wip.push_back( canvas_item_editor->snap_point(cpoint) );
245 edited_point=wip.size();
246 canvas_item_editor->update();
247 return true;
248
249 //add wip point
250 }
251 }
252 } else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) {
253 _wip_close();
254 }
255
256
257
258 } break;
259
260 case MODE_EDIT: {
261
262 if (mb.button_index==BUTTON_LEFT) {
263 if (mb.pressed) {
264
265 if (mb.mod.control) {
266
267
268 if (poly.size() < 3) {
269
270 undo_redo->create_action(TTR("Edit Poly"));
271 undo_redo->add_undo_method(node,"set_polygon",poly);
272 poly.push_back(cpoint);
273 undo_redo->add_do_method(node,"set_polygon",poly);
274 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
275 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
276 undo_redo->commit_action();
277 return true;
278 }
279
280 //search edges
281 int closest_idx=-1;
282 Vector2 closest_pos;
283 real_t closest_dist=1e10;
284 for(int i=0;i<poly.size();i++) {
285
286 Vector2 points[2] ={ xform.xform(poly[i]),
287 xform.xform(poly[(i+1)%poly.size()]) };
288
289 Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points);
290 if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2)
291 continue; //not valid to reuse point
292
293 real_t d = cp.distance_to(gpoint);
294 if (d<closest_dist && d<grab_treshold) {
295 closest_dist=d;
296 closest_pos=cp;
297 closest_idx=i;
298 }
299
300
301 }
302
303 if (closest_idx>=0) {
304
305 pre_move_edit=poly;
306 poly.insert(closest_idx+1,canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos)));
307 edited_point=closest_idx+1;
308 edited_point_pos=canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos));
309 node->set_polygon(poly);
310 canvas_item_editor->update();
311 return true;
312 }
313 } else {
314
315 //look for points to move
316
317 int closest_idx=-1;
318 Vector2 closest_pos;
319 real_t closest_dist=1e10;
320 for(int i=0;i<poly.size();i++) {
321
322 Vector2 cp =xform.xform(poly[i]);
323
324 real_t d = cp.distance_to(gpoint);
325 if (d<closest_dist && d<grab_treshold) {
326 closest_dist=d;
327 closest_pos=cp;
328 closest_idx=i;
329 }
330
331 }
332
333 if (closest_idx>=0) {
334
335 pre_move_edit=poly;
336 edited_point=closest_idx;
337 edited_point_pos=xform.affine_inverse().xform(closest_pos);
338 canvas_item_editor->update();
339 return true;
340 }
341 }
342 } else {
343
344 if (edited_point!=-1) {
345
346 //apply
347
348 ERR_FAIL_INDEX_V(edited_point,poly.size(),false);
349 poly[edited_point]=edited_point_pos;
350 undo_redo->create_action(TTR("Edit Poly"));
351 undo_redo->add_do_method(node,"set_polygon",poly);
352 undo_redo->add_undo_method(node,"set_polygon",pre_move_edit);
353 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
354 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
355 undo_redo->commit_action();
356
357 edited_point=-1;
358 return true;
359 }
360 }
361 } if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) {
362
363
364
365 int closest_idx=-1;
366 Vector2 closest_pos;
367 real_t closest_dist=1e10;
368 for(int i=0;i<poly.size();i++) {
369
370 Vector2 cp =xform.xform(poly[i]);
371
372 real_t d = cp.distance_to(gpoint);
373 if (d<closest_dist && d<grab_treshold) {
374 closest_dist=d;
375 closest_pos=cp;
376 closest_idx=i;
377 }
378
379 }
380
381 if (closest_idx>=0) {
382
383
384 undo_redo->create_action(TTR("Edit Poly (Remove Point)"));
385 undo_redo->add_undo_method(node,"set_polygon",poly);
386 poly.remove(closest_idx);
387 undo_redo->add_do_method(node,"set_polygon",poly);
388 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
389 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
390 undo_redo->commit_action();
391 return true;
392 }
393
394 }
395
396
397
398 } break;
399 }
400
401 #endif
402 } break;
403 case InputEvent::MOUSE_MOTION: {
404
405 const InputEventMouseMotion &mm = p_event.mouse_motion;
406
407 if (action != ACTION_NONE) {
408
409 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
410 Vector2 gpoint = Point2(mm.x, mm.y);
411 Vector2 cpoint = !mm.mod.alt ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint)));
412
413 Ref<Curve2D> curve = node->get_curve();
414
415 Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from);
416
417 switch (action) {
418
419 case ACTION_MOVING_POINT: {
420
421 curve->set_point_pos(action_point, cpoint);
422 } break;
423 case ACTION_MOVING_IN: {
424
425 curve->set_point_in(action_point, new_pos);
426
427 } break;
428 case ACTION_MOVING_OUT: {
429
430 curve->set_point_out(action_point, new_pos);
431
432 } break;
433 }
434
435 canvas_item_editor->get_viewport_control()->update();
436 return true;
437 }
438
439 #if 0
440 if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) {
441
442
443 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
444
445 Vector2 gpoint = Point2(mm.x,mm.y);
446 edited_point_pos = canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint));
447 canvas_item_editor->update();
448
449 }
450 #endif
451 } break;
452 }
453
454 return false;
455 }
_canvas_draw()456 void Path2DEditor::_canvas_draw() {
457
458 if (!node)
459 return;
460
461 if (!node->is_visible())
462 return;
463
464 if (!node->get_curve().is_valid())
465 return;
466
467 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
468 Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
469 Size2 handle_size = handle->get_size();
470
471 Ref<Curve2D> curve = node->get_curve();
472
473 int len = curve->get_point_count();
474 Control *vpc = canvas_item_editor->get_viewport_control();
475
476 for (int i = 0; i < len; i++) {
477
478 Vector2 point = xform.xform(curve->get_point_pos(i));
479 vpc->draw_texture_rect(handle, Rect2(point - handle_size * 0.5, handle_size), false, Color(1, 1, 1, 1));
480
481 if (i < len - 1) {
482 Vector2 pointout = xform.xform(curve->get_point_pos(i) + curve->get_point_out(i));
483 vpc->draw_line(point, pointout, Color(0.5, 0.5, 1.0, 0.8), 1.0);
484 vpc->draw_texture_rect(handle, Rect2(pointout - handle_size * 0.5, handle_size), false, Color(1, 0.5, 1, 0.3));
485 }
486
487 if (i > 0) {
488 Vector2 pointin = xform.xform(curve->get_point_pos(i) + curve->get_point_in(i));
489 vpc->draw_line(point, pointin, Color(0.5, 0.5, 1.0, 0.8), 1.0);
490 vpc->draw_texture_rect(handle, Rect2(pointin - handle_size * 0.5, handle_size), false, Color(1, 0.5, 1, 0.3));
491 }
492 }
493 }
494
_node_visibility_changed()495 void Path2DEditor::_node_visibility_changed() {
496 if (!node)
497 return;
498
499 canvas_item_editor->get_viewport_control()->update();
500 }
501
edit(Node * p_path2d)502 void Path2DEditor::edit(Node *p_path2d) {
503
504 if (!canvas_item_editor) {
505 canvas_item_editor = CanvasItemEditor::get_singleton();
506 }
507
508 if (p_path2d) {
509
510 node = p_path2d->cast_to<Path2D>();
511 if (!canvas_item_editor->get_viewport_control()->is_connected("draw", this, "_canvas_draw"))
512 canvas_item_editor->get_viewport_control()->connect("draw", this, "_canvas_draw");
513 if (!node->is_connected("visibility_changed", this, "_node_visibility_changed"))
514 node->connect("visibility_changed", this, "_node_visibility_changed");
515
516 } else {
517
518 if (canvas_item_editor->get_viewport_control()->is_connected("draw", this, "_canvas_draw"))
519 canvas_item_editor->get_viewport_control()->disconnect("draw", this, "_canvas_draw");
520
521 // node may have been deleted at this point
522 if (node && node->is_connected("visibility_changed", this, "_node_visibility_changed"))
523 node->disconnect("visibility_changed", this, "_node_visibility_changed");
524 node = NULL;
525 }
526 }
527
_bind_methods()528 void Path2DEditor::_bind_methods() {
529
530 //ObjectTypeDB::bind_method(_MD("_menu_option"),&Path2DEditor::_menu_option);
531 ObjectTypeDB::bind_method(_MD("_canvas_draw"), &Path2DEditor::_canvas_draw);
532 ObjectTypeDB::bind_method(_MD("_node_visibility_changed"), &Path2DEditor::_node_visibility_changed);
533 ObjectTypeDB::bind_method(_MD("_mode_selected"), &Path2DEditor::_mode_selected);
534 }
535
_mode_selected(int p_mode)536 void Path2DEditor::_mode_selected(int p_mode) {
537
538 if (p_mode == MODE_CREATE) {
539
540 curve_create->set_pressed(true);
541 curve_edit->set_pressed(false);
542 curve_edit_curve->set_pressed(false);
543 curve_del->set_pressed(false);
544 } else if (p_mode == MODE_EDIT) {
545
546 curve_create->set_pressed(false);
547 curve_edit->set_pressed(true);
548 curve_edit_curve->set_pressed(false);
549 curve_del->set_pressed(false);
550 } else if (p_mode == MODE_EDIT_CURVE) {
551
552 curve_create->set_pressed(false);
553 curve_edit->set_pressed(false);
554 curve_edit_curve->set_pressed(true);
555 curve_del->set_pressed(false);
556 } else if (p_mode == MODE_DELETE) {
557
558 curve_create->set_pressed(false);
559 curve_edit->set_pressed(false);
560 curve_edit_curve->set_pressed(false);
561 curve_del->set_pressed(true);
562 } else if (p_mode == ACTION_CLOSE) {
563
564 //?
565
566 if (!node->get_curve().is_valid())
567 return;
568 if (node->get_curve()->get_point_count() < 3)
569 return;
570
571 Vector2 begin = node->get_curve()->get_point_pos(0);
572 Vector2 end = node->get_curve()->get_point_pos(node->get_curve()->get_point_count() - 1);
573 if (begin.distance_to(end) < CMP_EPSILON)
574 return;
575
576 undo_redo->create_action(TTR("Remove Point from Curve"));
577 undo_redo->add_do_method(node->get_curve().ptr(), "add_point", begin);
578 undo_redo->add_undo_method(node->get_curve().ptr(), "remove_point", node->get_curve()->get_point_count());
579 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
580 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
581 undo_redo->commit_action();
582 return;
583 }
584
585 mode = Mode(p_mode);
586 }
587
Path2DEditor(EditorNode * p_editor)588 Path2DEditor::Path2DEditor(EditorNode *p_editor) {
589
590 canvas_item_editor = NULL;
591 editor = p_editor;
592 undo_redo = editor->get_undo_redo();
593
594 mode = MODE_EDIT;
595
596 action = ACTION_NONE;
597 #if 0
598 options = memnew( MenuButton );
599 add_child(options);
600 options->set_area_as_parent_rect();
601 options->set_text("Polygon");
602 //options->get_popup()->add_item("Parse BBCode",PARSE_BBCODE);
603 options->get_popup()->connect("item_pressed", this,"_menu_option");
604 #endif
605
606 base_hb = memnew(HBoxContainer);
607 CanvasItemEditor::get_singleton()->add_control_to_menu_panel(base_hb);
608
609 sep = memnew(VSeparator);
610 base_hb->add_child(sep);
611 curve_edit = memnew(ToolButton);
612 curve_edit->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveEdit", "EditorIcons"));
613 curve_edit->set_toggle_mode(true);
614 curve_edit->set_focus_mode(Control::FOCUS_NONE);
615 curve_edit->set_tooltip(TTR("Select Points") + "\n" + TTR("Shift+Drag: Select Control Points") + "\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Click: Add Point") + "\n" + TTR("Right Click: Delete Point"));
616 curve_edit->connect("pressed", this, "_mode_selected", varray(MODE_EDIT));
617 base_hb->add_child(curve_edit);
618 curve_edit_curve = memnew(ToolButton);
619 curve_edit_curve->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveCurve", "EditorIcons"));
620 curve_edit_curve->set_toggle_mode(true);
621 curve_edit_curve->set_focus_mode(Control::FOCUS_NONE);
622 curve_edit_curve->set_tooltip(TTR("Select Control Points (Shift+Drag)"));
623 curve_edit_curve->connect("pressed", this, "_mode_selected", varray(MODE_EDIT_CURVE));
624 base_hb->add_child(curve_edit_curve);
625 curve_create = memnew(ToolButton);
626 curve_create->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveCreate", "EditorIcons"));
627 curve_create->set_toggle_mode(true);
628 curve_create->set_focus_mode(Control::FOCUS_NONE);
629 curve_create->set_tooltip(TTR("Add Point (in empty space)") + "\n" + TTR("Split Segment (in curve)"));
630 curve_create->connect("pressed", this, "_mode_selected", varray(MODE_CREATE));
631 base_hb->add_child(curve_create);
632 curve_del = memnew(ToolButton);
633 curve_del->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveDelete", "EditorIcons"));
634 curve_del->set_toggle_mode(true);
635 curve_del->set_focus_mode(Control::FOCUS_NONE);
636 curve_del->set_tooltip(TTR("Delete Point"));
637 curve_del->connect("pressed", this, "_mode_selected", varray(MODE_DELETE));
638 base_hb->add_child(curve_del);
639 curve_close = memnew(ToolButton);
640 curve_close->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveClose", "EditorIcons"));
641 curve_close->set_focus_mode(Control::FOCUS_NONE);
642 curve_close->set_tooltip(TTR("Close Curve"));
643 curve_close->connect("pressed", this, "_mode_selected", varray(ACTION_CLOSE));
644 base_hb->add_child(curve_close);
645 base_hb->hide();
646
647 curve_edit->set_pressed(true);
648 }
649
edit(Object * p_object)650 void Path2DEditorPlugin::edit(Object *p_object) {
651
652 path2d_editor->edit(p_object->cast_to<Node>());
653 }
654
handles(Object * p_object) const655 bool Path2DEditorPlugin::handles(Object *p_object) const {
656
657 return p_object->is_type("Path2D");
658 }
659
make_visible(bool p_visible)660 void Path2DEditorPlugin::make_visible(bool p_visible) {
661
662 if (p_visible) {
663 path2d_editor->show();
664 path2d_editor->base_hb->show();
665
666 } else {
667
668 path2d_editor->hide();
669 path2d_editor->base_hb->hide();
670 path2d_editor->edit(NULL);
671 }
672 }
673
Path2DEditorPlugin(EditorNode * p_node)674 Path2DEditorPlugin::Path2DEditorPlugin(EditorNode *p_node) {
675
676 editor = p_node;
677 path2d_editor = memnew(Path2DEditor(p_node));
678 CanvasItemEditor::get_singleton()->add_control_to_menu_panel(path2d_editor);
679 path2d_editor->hide();
680 }
681
~Path2DEditorPlugin()682 Path2DEditorPlugin::~Path2DEditorPlugin() {
683 }
684