SConscript('collada/SCsub')

SConscript('doc/SCsub')

SConscript('fileserver/SCsub')

SConscript('icons/SCsub')

SConscript('import/SCsub')

draw_line(Point2(right_limit, 0), Point2(right_limit, get_size().height), linecolor);

close_icon_rect.position = Vector2(get_size().width - close_icon->get_width() - hsep, hsep);

close_icon_rect.size = close_icon->get_size();

if (node) {

int ofs = 0;

h = MAX(h, icon->get_height());

{ //draw OTHER curves

float scale = timeline->get_zoom_scale();

for (Map<int, Color>::Element *E = subtrack_colors.front(); E; E = E->next()) {

_draw_track(E->key(), E->get());

animation = p_animation;

track = p_track;

update();

}

void AnimationBezierTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) {

timeline = p_timeline;

}

void AnimationBezierTrackEdit::set_editor(AnimationTrackEditor *p_editor) {

editor = p_editor;

}

void AnimationBezierTrackEdit::_play_position_draw() {

play_position->set_mouse_filter(MOUSE_FILTER_PASS);

add_child(play_position);

play_position->set_anchors_and_margins_preset(PRESET_WIDE);

set_focus_mode(FOCUS_CLICK);

v_scroll = 0;

menu = memnew(PopupMenu);

add_child(menu);

//set_mouse_filter(MOUSE_FILTER_PASS); //scroll has to work too for selection

}

Vector<Rect2> view_rects;

Rect2 close_icon_rect;

Variant::Type t = Variant::Type(int(p_value));

if (t != args[idx].get_type()) {

if (Variant::can_convert(args[idx].get_type(), t)) {

Variant old = args[idx];

Variant *ptrs[1] = { &old };

} break;

case Animation::TYPE_METHOD: {

p_list->push_back(PropertyInfo(Variant::INT, "arg_count", PROPERTY_HINT_RANGE, "0,5,1"));

Dictionary d = animation->track_get_key_value(track, key);

}

animations += "[stop]";

} break;

}

Variant::Type t = Variant::Type(int(p_value));

if (t != args[idx].get_type()) {

if (Variant::can_convert(args[idx].get_type(), t)) {

Variant old = args[idx];

Variant *ptrs[1] = { &old };

} break;

case Animation::TYPE_METHOD: {

p_list->push_back(PropertyInfo(Variant::INT, "arg_count", PROPERTY_HINT_RANGE, "0,5,1"));

Dictionary d = animation->track_get_key_value(first_track, first_key);

}

animations += "[stop]";

} break;

}

}

int AnimationTimelineEdit::get_buttons_width() const {

int total_w = interp_mode->get_width() + interp_type->get_width() + loop_type->get_width() + remove_icon->get_width();

total_w += (down_icon->get_width() + 4 * EDSCALE) * 4;

int AnimationTimelineEdit::get_name_limit() const {

int limit = MAX(name_limit, add_track->get_minimum_size().width + hsize_icon->get_width());

if (l <= 0)

l = 0.001; //avoid crashor

hsize_rect = Rect2(get_name_limit() - hsize_icon->get_width() - 2 * EDSCALE, (get_size().height - hsize_icon->get_height()) / 2, hsize_icon->get_width(), hsize_icon->get_height());

draw_texture(hsize_icon, hsize_rect.position);

void AnimationTimelineEdit::set_zoom(Range *p_zoom) {

zoom = p_zoom;

}

void AnimationTimelineEdit::set_play_position(float p_pos) {

play_position->set_mouse_filter(MOUSE_FILTER_PASS);

add_child(play_position);

play_position->set_anchors_and_margins_preset(PRESET_WIDE);

add_track = memnew(MenuButton);

add_track->set_position(Vector2(0, 0));

length->set_custom_minimum_size(Vector2(70 * EDSCALE, 0));

length->set_hide_slider(true);

length->set_tooltip(TTR("Animation length (seconds)"));

len_hb->add_child(length);

loop = memnew(ToolButton);

loop->set_tooltip(TTR("Animation Looping"));

loop->set_toggle_mode(true);

len_hb->add_child(loop);

add_child(len_hb);

add_track->hide();

len_hb->hide();

panning_timeline = false;

Ref<Font> font = get_font("font", "Label");

Color color = get_color("font_color", "Label");

get_icon("KeyValue", "EditorIcons"),

get_icon("KeyXform", "EditorIcons"),

get_icon("KeyCall", "EditorIcons"),

{

int ofs = in_group ? check->get_width() : 0; //not the best reference for margin but..

draw_texture(check, check_rect.position);

ofs += check->get_width() + hsep;

draw_texture(type_icon, Point2(ofs, int(get_size().height - type_icon->get_height()) / 2));

ofs += type_icon->get_width() + hsep;

}

text_color.a *= 0.7;

} else if (node) {

draw_texture(icon, Point2(ofs, int(get_size().height - icon->get_height()) / 2));

icon_cache = icon;

{

get_icon("InterpWrapClamp", "EditorIcons"),

get_icon("InterpWrapLoop", "EditorIcons"),

};

get_icon("InterpRaw", "EditorIcons"),

get_icon("InterpLinear", "EditorIcons"),

get_icon("InterpCubic", "EditorIcons")

};

get_icon("TrackContinuous", "EditorIcons"),

get_icon("TrackDiscrete", "EditorIcons"),

get_icon("TrackTrigger", "EditorIcons"),

int ofs = get_size().width - timeline->get_buttons_width();

draw_line(Point2(ofs, 0), Point2(ofs, get_size().height), linecolor, Math::round(EDSCALE));

update_mode = Animation::UPDATE_CONTINUOUS;

}

update_mode_rect.position.x = ofs;

update_mode_rect.position.y = int(get_size().height - update_icon->get_height()) / 2;

update_mode_rect.size.x += down_icon->get_width();

bezier_edit_rect = Rect2();

} else if (animation->track_get_type(track) == Animation::TYPE_BEZIER) {

update_mode_rect.size.x += down_icon->get_width();

bezier_edit_rect.position = update_mode_rect.position + (update_mode_rect.size - bezier_icon->get_size()) / 2;

bezier_edit_rect.size = bezier_icon->get_size();

Animation::InterpolationType interp_mode = animation->track_get_interpolation_type(track);

interp_mode_rect.position.x = ofs;

interp_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;

bool loop_wrap = animation->track_get_interpolation_loop_wrap(track);

loop_mode_rect.position.x = ofs;

loop_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;

{

//erase

remove_rect.position.x = ofs + ((get_size().width - ofs) - icon->get_width()) / 2;

remove_rect.position.y = int(get_size().height - icon->get_height()) / 2;

if (p_x < p_clip_left || p_x > p_clip_right)

return;

// Override type icon for invalid value keys, unless selected.

if (!p_selected && animation->track_get_type(track) == Animation::TYPE_VALUE) {

void AnimationTrackEdit::draw_fg(int p_clip_left, int p_clip_right) {

}

draw_texture_region_clipped(p_texture, Rect2(p_pos, p_texture->get_size()), Rect2(Point2(), p_texture->get_size()));

}

int clip_left = timeline->get_name_limit();

int clip_right = get_size().width - timeline->get_buttons_width();

track = p_track;

update();

get_icon("KeyValue", "EditorIcons"),

get_icon("KeyXform", "EditorIcons"),

get_icon("KeyCall", "EditorIcons"),

Size2 AnimationTrackEdit::get_minimum_size() const {

Ref<Font> font = get_font("font", "Label");

int separation = get_constant("vseparation", "ItemList");

void AnimationTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) {

timeline = p_timeline;

}

void AnimationTrackEdit::set_editor(AnimationTrackEditor *p_editor) {

editor = p_editor;

if (!menu) {

menu = memnew(PopupMenu);

add_child(menu);

}

menu->clear();

menu->add_icon_item(get_icon("TrackContinuous", "EditorIcons"), TTR("Continuous"), MENU_CALL_MODE_CONTINUOUS);

if (!menu) {

menu = memnew(PopupMenu);

add_child(menu);

}

menu->clear();

menu->add_icon_item(get_icon("InterpRaw", "EditorIcons"), TTR("Nearest"), MENU_INTERPOLATION_NEAREST);

if (!menu) {

menu = memnew(PopupMenu);

add_child(menu);

}

menu->clear();

menu->add_icon_item(get_icon("InterpWrapClamp", "EditorIcons"), TTR("Clamp Loop Interp"), MENU_LOOP_CLAMP);

if (!menu) {

menu = memnew(PopupMenu);

add_child(menu);

}

menu->clear();

path = memnew(LineEdit);

add_child(path);

path->set_as_toplevel(true);

}

path->set_text(animation->track_get_path(track));

play_position->set_mouse_filter(MOUSE_FILTER_PASS);

add_child(play_position);

play_position->set_anchors_and_margins_preset(PRESET_WIDE);

set_focus_mode(FOCUS_CLICK);

set_mouse_filter(MOUSE_FILTER_PASS); //scroll has to work too for selection

}

&args[5]

};

return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_value_track_edit", (const Variant **)&argptrs, 6, ce).operator Object *());

}

return NULL;

}

}

icon = p_type;

node_name = p_name;

node = p_node;

void AnimationTrackEditGroup::set_timeline(AnimationTimelineEdit *p_timeline) {

timeline = p_timeline;

}

void AnimationTrackEditGroup::set_root(Node *p_root) {

track_edits[_get_track_selected()]->release_focus();

}

if (animation.is_valid()) {

_clear_selection();

}

animation = p_anim;

_update_tracks();

if (animation.is_valid()) {

hscroll->show();

edit->set_disabled(false);

void AnimationTrackEditor::set_root(Node *p_root) {

if (root) {

}

root = p_root;

if (root) {

}

_update_tracks();

if (!group_sort.has(base_path)) {

AnimationTrackEditGroup *g = memnew(AnimationTrackEditGroup);

String name = base_path;

String tooltip;

if (root && root->has_node(base_path)) {

track_edit->grab_focus();

}

}

}

}

if (p_what == NOTIFICATION_READY) {

}

if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {

Variant arg = E->get().default_arguments[i - first_defarg];

params.push_back(arg);

} else {

Variant arg = Variant::construct(E->get().arguments[i].type, NULL, 0, ce);

params.push_back(arg);

}

}

String text;

if (node) {

if (has_icon(node->get_class(), "EditorIcons")) {

icon = get_icon(node->get_class(), "EditorIcons");

timeline = memnew(AnimationTimelineEdit);

timeline->set_undo_redo(undo_redo);

timeline_vbox->add_child(timeline);

scroll = memnew(ScrollContainer);

timeline_vbox->add_child(scroll);

VScrollBar *sb = scroll->get_v_scrollbar();

scroll->remove_child(sb);

timeline_scroll->add_child(sb); //move here so timeline and tracks are always aligned

bezier_edit = memnew(AnimationBezierTrackEdit);

timeline_vbox->add_child(bezier_edit);

bezier_edit->set_timeline(timeline);

bezier_edit->hide();

bezier_edit->set_v_size_flags(SIZE_EXPAND_FILL);

timeline_vbox->set_custom_minimum_size(Size2(0, 150) * EDSCALE);

hscroll = memnew(HScrollBar);

hscroll->share(timeline);

hscroll->hide();

timeline_vbox->add_child(hscroll);

timeline->set_hscroll(hscroll);

imported_anim_warning = memnew(Button);

imported_anim_warning->hide();

imported_anim_warning->set_tooltip(TTR("Warning: Editing imported animation"));

bottom_hb->add_child(imported_anim_warning);

bottom_hb->add_spacer();

selected_filter = memnew(ToolButton);

selected_filter->set_toggle_mode(true);

selected_filter->set_tooltip(TTR("Only show tracks from nodes selected in tree."));

bottom_hb->add_child(selected_filter);

view_group = memnew(ToolButton);

view_group->set_toggle_mode(true);

view_group->set_tooltip(TTR("Group tracks by node or display them as plain list."));

step->set_custom_minimum_size(Size2(100, 0) * EDSCALE);

step->set_tooltip(TTR("Animation step value."));

bottom_hb->add_child(step);

step->set_read_only(true);

snap_mode = memnew(OptionButton);

snap_mode->add_item(TTR("Seconds"));

snap_mode->add_item(TTR("FPS"));

bottom_hb->add_child(snap_mode);

snap_mode->set_disabled(true);

bottom_hb->add_child(memnew(VSeparator));

edit->get_popup()->add_item(TTR("Optimize Animation"), EDIT_OPTIMIZE_ANIMATION);

edit->get_popup()->add_item(TTR("Clean-Up Animation"), EDIT_CLEAN_UP_ANIMATION);

pick_track = memnew(SceneTreeDialog);

add_child(pick_track);

pick_track->set_title(TTR("Pick the node that will be animated:"));

prop_selector = memnew(PropertySelector);

add_child(prop_selector);

method_selector = memnew(PropertySelector);

add_child(method_selector);

inserting = false;

insert_query = false;

insert_confirm = memnew(ConfirmationDialog);

add_child(insert_confirm);

VBoxContainer *icvb = memnew(VBoxContainer);

insert_confirm->add_child(icvb);

insert_confirm_text = memnew(Label);

box_selection->set_as_toplevel(true);

box_selection->set_mouse_filter(MOUSE_FILTER_IGNORE);

box_selection->hide();

box_selecting = false;

//default plugins

optimize_max_angle->set_value(22);

optimize_dialog->get_ok()->set_text(TTR("Optimize"));

//

cleanup_dialog->set_title(TTR("Clean-Up Animation(s) (NO UNDO!)"));

cleanup_dialog->get_ok()->set_text(TTR("Clean-Up"));

//

scale_dialog = memnew(ConfirmationDialog);

scale->set_max(99999);

scale->set_step(0.001);

vbc->add_margin_child(TTR("Scale Ratio:"), scale);

add_child(scale_dialog);

track_copy_dialog = memnew(ConfirmationDialog);

Button *select_all_button = memnew(Button);

select_all_button->set_text(TTR("Select All/None"));

track_vbox->add_child(select_all_button);

track_copy_select = memnew(Tree);

track_copy_select->set_v_size_flags(SIZE_EXPAND_FILL);

track_copy_select->set_hide_root(true);

track_vbox->add_child(track_copy_select);

animation_changing_awaiting_update = false;

}

Rect2 remove_rect;

Rect2 bezier_edit_rect;

PopupMenu *menu;

void _zoom_changed();

String path_cache;

void _menu_selected(int p_index);

virtual void draw_fg(int p_clip_left, int p_clip_right);

//helper

void draw_rect_clipped(const Rect2 &p_rect, const Color &p_color, bool p_filled = true);

int get_track() const;

class AnimationTrackEditGroup : public Control {

GDCLASS(AnimationTrackEditGroup, Control);

String node_name;

NodePath node;

Node *root;

void _notification(int p_what);

public:

virtual Size2 get_minimum_size() const;

void set_timeline(AnimationTimelineEdit *p_timeline);

void set_root(Node *p_root);

/// BOOL ///

int AnimationTrackEditBool::get_key_height() const {

return checked->get_height();

}

Rect2 AnimationTrackEditBool::get_key_rect(int p_index, float p_pixels_sec) {

return Rect2(-checked->get_width() / 2, 0, checked->get_width(), get_size().height);

}

void AnimationTrackEditBool::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {

bool checked = get_animation()->track_get_key_value(get_track(), p_index);

Vector2 ofs(p_x - icon->get_width() / 2, int(get_size().height - icon->get_height()) / 2);

}

AnimationTrackEditAudio::AnimationTrackEditAudio() {

}

/// SPRITE FRAME / FRAME_COORDS ///

if (Object::cast_to<Sprite>(object) || Object::cast_to<Sprite3D>(object)) {

if (!texture.is_valid()) {

return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);

}

animation = get_animation()->track_get_key_value(animation_track, animaiton_index);

}

if (!texture.is_valid()) {

return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);

}

return;

}

Rect2 region;

if (Object::cast_to<Sprite>(object) || Object::cast_to<Sprite3D>(object)) {

int AnimationTrackEditVolumeDB::get_key_height() const {

return volume_texture->get_height() * 1.2;

}

void AnimationTrackEditVolumeDB::draw_bg(int p_clip_left, int p_clip_right) {

int tex_h = volume_texture->get_height();

int y_from = (get_size().height - tex_h) / 2;

void AnimationTrackEditVolumeDB::draw_fg(int p_clip_left, int p_clip_right) {

int tex_h = volume_texture->get_height();

int y_from = (get_size().height - tex_h) / 2;

int db0 = y_from + (24 / 80.0) * tex_h;

to_x = p_clip_right;

}

int tex_h = volume_texture->get_height();

int y_from = (get_size().height - tex_h) / 2;

}

AnimationTrackEditTypeAudio::AnimationTrackEditTypeAudio() {

len_resizing = false;

}

class AnimationTrackEditBool : public AnimationTrackEdit {

GDCLASS(AnimationTrackEditBool, AnimationTrackEdit);

public:

virtual int get_key_height() const;

return Array();

Variant arr = o->get(property);

if (!arr.is_array()) {

arr = Variant::construct(default_type, NULL, 0, ce);

}

return arr;

} else if (newsize > size) {

Variant init;

Variant::Type new_type = subtype;

if (new_type == Variant::NIL && size) {

new_type = arr.get(size - 1).get_type();

Variant value = arr.get(idx);

if (value.get_type() != type && type >= 0 && type < Variant::VARIANT_MAX) {

Variant new_value = Variant::construct(Variant::Type(type), NULL, 0, ce);

UndoRedo *ur = EditorNode::get_undo_redo();

void FindReplaceBar::_replace_all() {

// Line as x so it gets priority in comparison, column as y.

Point2i orig_cursor(text_edit->cursor_get_line(), text_edit->cursor_get_column());

Point2i prev_match = Point2(-1, -1);

matches_label->add_color_override("font_color", rc > 0 ? get_color("font_color", "Label") : get_color("error_color", "Editor"));

matches_label->set_text(vformat(TTR("%d replaced."), rc));

results_count = -1;

}

if (selection_only->is_pressed() && text_edit->is_selection_active()) {

_replace_all();

_hide_bar();

}

}

results_count = -1;

text_edit = p_text_edit;

}

void FindReplaceBar::_bind_methods() {

search_text = memnew(LineEdit);

vbc_lineedit->add_child(search_text);

search_text->set_custom_minimum_size(Size2(100 * EDSCALE, 0));

matches_label = memnew(Label);

hbc_button_search->add_child(matches_label);

find_prev = memnew(ToolButton);

hbc_button_search->add_child(find_prev);

find_prev->set_focus_mode(FOCUS_NONE);

find_next = memnew(ToolButton);

hbc_button_search->add_child(find_next);

find_next->set_focus_mode(FOCUS_NONE);

case_sensitive = memnew(CheckBox);

hbc_option_search->add_child(case_sensitive);

case_sensitive->set_text(TTR("Match Case"));

case_sensitive->set_focus_mode(FOCUS_NONE);

whole_words = memnew(CheckBox);

hbc_option_search->add_child(whole_words);

whole_words->set_text(TTR("Whole Words"));

whole_words->set_focus_mode(FOCUS_NONE);

// replace toolbar

replace_text = memnew(LineEdit);

vbc_lineedit->add_child(replace_text);

replace_text->set_custom_minimum_size(Size2(100 * EDSCALE, 0));

replace = memnew(Button);

hbc_button_replace->add_child(replace);

replace->set_text(TTR("Replace"));

replace_all = memnew(Button);

hbc_button_replace->add_child(replace_all);

replace_all->set_text(TTR("Replace All"));

selection_only = memnew(CheckBox);

hbc_option_replace->add_child(selection_only);

selection_only->set_text(TTR("Selection Only"));

selection_only->set_focus_mode(FOCUS_NONE);

hide_button = memnew(TextureButton);

add_child(hide_button);

hide_button->set_focus_mode(FOCUS_NONE);

hide_button->set_v_size_flags(SIZE_SHRINK_CENTER);

}

accept_event();

return;

}

}

void CodeTextEditor::_text_editor_gui_input(const Ref<InputEvent> &p_event) {

text_editor->code_complete(entries, forced);

}

switch (p_option.kind) {

case ScriptCodeCompletionOption::KIND_CLASS: {

if (has_icon(p_option.display, "EditorIcons")) {

error_column = 0;

toggle_scripts_button = memnew(ToolButton);

status_bar->add_child(toggle_scripts_button);

toggle_scripts_button->hide();

scroll->add_child(error);

error->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER);

error->set_mouse_filter(MOUSE_FILTER_STOP);

// Warnings

warning_button = memnew(ToolButton);

status_bar->add_child(warning_button);

warning_button->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER);

warning_button->set_default_cursor_shape(CURSOR_POINTING_HAND);

warning_button->set_tooltip(TTR("Warnings"));

warning_count_label = memnew(Label);

warning_count_label->set_tooltip(TTR("Warnings"));

warning_count_label->add_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_color("warning_color", "Editor"));

warning_count_label->add_font_override("font", EditorNode::get_singleton()->get_gui_base()->get_font("status_source", "EditorFonts"));

is_warnings_panel_opened = false;

set_warning_nb(0);

line_and_col_txt->set_tooltip(TTR("Line and column numbers."));

line_and_col_txt->set_mouse_filter(MOUSE_FILTER_STOP);

Vector<String> cs;

cs.push_back(".");

cs.push_back(",");

cs.push_back("=");

cs.push_back("$");

text_editor->set_completion(true, cs);

font_resize_val = 0;

font_size = EditorSettings::get_singleton()->get("interface/editor/code_font_size");

add_child(font_resize_timer);

font_resize_timer->set_one_shot(true);

font_resize_timer->set_wait_time(0.07);

}

void _update_font();

void _complete_request();

void _font_resize_timeout();

bool _add_font_size(int p_delta);

return;

}

Node *target = tree->get_selected();

if (target->get_script().is_null()) {

if (!target->has_method(dst_method->get_text())) {

error->set_text(TTR("Target method not found. Specify a valid method or attach a script to the target node."));

}

/*

* Adds a new parameter bind to connection.

*/

void ConnectDialog::_add_bind() {

case Variant::INT: value = 0; break;

case Variant::REAL: value = 0.0; break;

case Variant::STRING: value = ""; break;

case Variant::VECTOR2: value = Vector2(); break;

case Variant::RECT2: value = Rect2(); break;

case Variant::VECTOR3: value = Vector3(); break;

ClassDB::bind_method("_advanced_pressed", &ConnectDialog::_advanced_pressed);

ClassDB::bind_method("_cancel", &ConnectDialog::_cancel_pressed);

ClassDB::bind_method("_tree_node_selected", &ConnectDialog::_tree_node_selected);

ClassDB::bind_method("_add_bind", &ConnectDialog::_add_bind);

ClassDB::bind_method("_remove_bind", &ConnectDialog::_remove_bind);

ClassDB::bind_method("_update_ok_enabled", &ConnectDialog::_update_ok_enabled);

* If creating a connection from scratch, sensible defaults are used.

* If editing an existing connection, previous data is retained.

*/

set_hide_on_ok(false);

tree = memnew(SceneTreeEditor(false));

tree->set_connecting_signal(true);

tree->set_connect_to_script_mode(true);

Node *mc = vbc_left->add_margin_child(TTR("Connect to Script:"), tree, true);

type_list->add_item("int", Variant::INT);

type_list->add_item("real", Variant::REAL);

type_list->add_item("String", Variant::STRING);

type_list->add_item("Vector2", Variant::VECTOR2);

type_list->add_item("Rect2", Variant::RECT2);

type_list->add_item("Vector3", Variant::VECTOR3);

Button *add_bind = memnew(Button);

add_bind->set_text(TTR("Add"));

add_bind_hb->add_child(add_bind);

Button *del_bind = memnew(Button);

del_bind->set_text(TTR("Remove"));

add_bind_hb->add_child(del_bind);

vbc_right->add_margin_child(TTR("Add Extra Call Argument:"), add_bind_hb);

dst_method = memnew(LineEdit);

dst_method->set_h_size_flags(SIZE_EXPAND_FILL);

dstm_hb->add_child(dst_method);

advanced = memnew(CheckButton);

dstm_hb->add_child(advanced);

advanced->set_text(TTR("Advanced"));

// Add spacing so the tree and inspector are the same size.

Control *spacing = memnew(Control);

Node *target = selectedNode->get_node(dst_path);

ERR_FAIL_COND(!target);

cToMake.source = connect_dialog->get_source();

cToMake.target = target;

cToMake.signal = connect_dialog->get_signal_name();

add_script_function = !found_inherited_function;

}

if (add_script_function) {

// Pick up args here before "it" is deleted by update_tree.

script_function_args = it->get_metadata(0).operator Dictionary()["args"];

for (int i = 0; i < cToMake.binds.size(); i++) {

}

}

/*

* Creates single connection w/ undo-redo functionality.

*/

Node *source = static_cast<Node *>(cToMake.source);

Node *target = static_cast<Node *>(cToMake.target);

undo_redo->create_action(vformat(TTR("Connect '%s' to '%s'"), String(cToMake.signal), String(cToMake.method)));

undo_redo->add_do_method(this, "update_tree");

undo_redo->add_undo_method(this, "update_tree");

undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree"); //to force redraw of scene tree

*/

void ConnectionsDock::_disconnect(TreeItem &item) {

ERR_FAIL_COND(c.source != selectedNode); // Shouldn't happen but... Bugcheck.

undo_redo->create_action(vformat(TTR("Disconnect '%s' from '%s'"), c.signal, c.method));

undo_redo->add_do_method(this, "update_tree");

undo_redo->add_undo_method(this, "update_tree");

undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree"); // To force redraw of scene tree.

undo_redo->create_action(vformat(TTR("Disconnect all from signal: '%s'"), signalName));

while (child) {

child = child->get_next();

}

StringName dst_method = "_on_" + midname + "_" + signal;

c.source = selectedNode;

c.signal = StringName(signalname);

c.target = dst_node;

/*

* Open connection dialog with Connection data to EDIT an existing connection.

*/

Node *src = static_cast<Node *>(cToEdit.source);

Node *dst = static_cast<Node *>(cToEdit.target);

if (_is_item_signal(item))

return;

ERR_FAIL_COND(c.source != selectedNode); //shouldn't happen but...bugcheck

if (!c.target)

while (base) {

List<MethodInfo> node_signals2;

String name;

if (!did_script) {

StringName signal_name = mi.name;

String signaldesc = "(";

if (mi.arguments.size()) {

for (int i = 0; i < mi.arguments.size(); i++) {

for (List<Object::Connection>::Element *F = connections.front(); F; F = F->next()) {

if (!(c.flags & CONNECT_PERSIST))

continue;

TreeItem *item2 = tree->create_item(item);

item2->set_text(0, path);

item2->set_icon(0, get_icon("Slot", "EditorIcons"));

}

}

vbc->add_child(hb);

hb->add_spacer();

hb->add_child(connect_button);

connect_dialog = memnew(ConnectDialog);

connect_dialog->set_as_toplevel(true);

disconnect_all_dialog = memnew(ConfirmationDialog);

disconnect_all_dialog->set_as_toplevel(true);

add_child(disconnect_all_dialog);

disconnect_all_dialog->set_text(TTR("Are you sure you want to remove all connections from this signal?"));

signal_menu = memnew(PopupMenu);

add_child(signal_menu);

signal_menu->add_item(TTR("Connect..."), CONNECT);

signal_menu->add_item(TTR("Disconnect All"), DISCONNECT_ALL);

slot_menu = memnew(PopupMenu);

add_child(slot_menu);

slot_menu->add_item(TTR("Edit..."), EDIT);

slot_menu->add_item(TTR("Go To Method"), GO_TO_SCRIPT);

slot_menu->add_item(TTR("Disconnect"), DISCONNECT);

add_constant_override("separation", 3 * EDSCALE);

}

GDCLASS(ConnectDialog, ConfirmationDialog);

Label *connect_to_label;

LineEdit *from_signal;

Node *source;

void ok_pressed();

void _cancel_pressed();

void _tree_node_selected();

void _add_bind();

void _remove_bind();

void _advanced_pressed();

bool get_oneshot() const;

bool is_editing() const;

void popup_dialog(const String &p_for_signal);

ConnectDialog();

Map<StringName, Map<StringName, String> > descr_cache;

void _make_or_edit_connection();

void _disconnect(TreeItem &item);

void _disconnect_all();

bool _is_item_signal(TreeItem &item);

void _open_connection_dialog(TreeItem &item);

void _go_to_script(TreeItem &item);

void _handle_signal_menu_option(int option);

switch (p_what) {

case NOTIFICATION_ENTER_TREE: {

search_box->set_right_icon(get_icon("Search", "EditorIcons"));

search_box->set_clear_button_enabled(true);

favorite->set_icon(get_icon("Favorites", "EditorIcons"));

} break;

case NOTIFICATION_EXIT_TREE: {

} break;

case NOTIFICATION_VISIBILITY_CHANGED: {

if (is_visible_in_tree()) {

favorites->set_hide_root(true);

favorites->set_hide_folding(true);

favorites->set_allow_reselect(true);

favorites->set_drag_forwarding(this);

favorites->add_constant_override("draw_guides", 1);

recent->set_hide_root(true);

recent->set_hide_folding(true);

recent->set_allow_reselect(true);

recent->add_constant_override("draw_guides", 1);

VBoxContainer *vbc = memnew(VBoxContainer);

favorite->set_flat(true);

favorite->set_toggle_mode(true);

search_hb->add_child(favorite);

vbc->add_margin_child(TTR("Search:"), search_hb);

search_options = memnew(Tree);

vbc->add_margin_child(TTR("Matches:"), search_options, true);

get_ok()->set_disabled(true);

register_text_enter(search_box);

set_hide_on_ok(false);

base_type = "Object";

preferred_search_result_type = "";

help_bit = memnew(EditorHelpBit);

vbc->add_margin_child(TTR("Description:"), help_bit);

type_blacklist.insert("PluginScript"); // PluginScript must be initialized before use, which is not possible here

type_blacklist.insert("ScriptCreateDialog"); // This is an exposed editor Node that doesn't have an Editor prefix.

void _confirmed();

void _text_changed(const String &p_newtext);

void add_type(const String &p_type, HashMap<String, TreeItem *> &p_types, TreeItem *p_root, TreeItem **to_select);