void EditorPlugin::get_breakpoints(List<String> *p_breakpoints) { if (get_script_instance() && get_script_instance()->has_method("get_breakpoints")) { PoolStringArray arr = get_script_instance()->call("get_breakpoints"); for (int i = 0; i < arr.size(); i++) p_breakpoints->push_back(arr[i]); } }
PoolStringArray mono_array_to_PoolStringArray(MonoArray *p_array) { PoolStringArray ret; int length = mono_array_length(p_array); for (int i = 0; i < length; i++) { MonoString *elem = mono_array_get(p_array, MonoString *, i); ret.push_back(mono_string_to_godot(elem)); } return ret; }
PoolStringArray HTTPClient::_get_response_headers() { List<String> rh; get_response_headers(&rh); PoolStringArray ret; ret.resize(rh.size()); int idx = 0; for (const List<String>::Element *E = rh.front(); E; E = E->next()) { ret.set(idx++, E->get()); } return ret; }
void ResourceFormatLoader::get_recognized_extensions(List<String> *p_extensions) const { if (get_script_instance() && get_script_instance()->has_method("get_recognized_extensions")) { PoolStringArray exts = get_script_instance()->call("get_recognized_extensions"); { PoolStringArray::Read r = exts.read(); for (int i = 0; i < exts.size(); ++i) { p_extensions->push_back(r[i]); } } } }
void PluginScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) { if (_desc.debug_get_globals) { PoolStringArray locals; Array values; _desc.debug_get_globals(_data, (godot_pool_string_array *)&locals, (godot_array *)&values, p_max_subitems, p_max_depth); for (int i = 0; i < locals.size(); i++) { p_locals->push_back(locals[i]); } for (int i = 0; i < values.size(); i++) { p_values->push_back(values[i]); } } }
void PluginScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) { if (_desc.debug_get_stack_level_members) { PoolStringArray members; Array values; _desc.debug_get_stack_level_members(_data, p_level, (godot_pool_string_array *)&members, (godot_array *)&values, p_max_subitems, p_max_depth); for (int i = 0; i < members.size(); i++) { p_members->push_back(members[i]); } for (int i = 0; i < values.size(); i++) { p_values->push_back(values[i]); } } }
void ResourceFormatLoader::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) { if (get_script_instance() && get_script_instance()->has_method("get_dependencies")) { PoolStringArray deps = get_script_instance()->call("get_dependencies", p_path, p_add_types); { PoolStringArray::Read r = deps.read(); for (int i = 0; i < deps.size(); ++i) { p_dependencies->push_back(r[i]); } } } }
PoolStringArray mono_array_to_PoolStringArray(MonoArray *p_array) { PoolStringArray ret; if (!p_array) return ret; int length = mono_array_length(p_array); ret.resize(length); for (int i = 0; i < length; i++) { MonoString *elem = mono_array_get(p_array, MonoString *, i); ret.set(i, mono_string_to_godot(elem)); } return ret; }
PoolStringArray ConfigFile::_get_section_keys(const String &p_section) const { List<String> s; get_section_keys(p_section, &s); PoolStringArray arr; arr.resize(s.size()); int idx = 0; for (const List<String>::Element *E = s.front(); E; E = E->next()) { arr.set(idx++, E->get()); } return arr; }
void FindInFiles::_scan_dir(String path, PoolStringArray &out_folders) { DirAccess *dir = DirAccess::open(path); if (dir == NULL) { print_line("Cannot open directory! " + path); return; } dir->list_dir_begin(); for (int i = 0; i < 1000; ++i) { String file = dir->get_next(); if (file == "") break; // Ignore special dirs and hidden dirs (such as .git and .import) if (file == "." || file == ".." || file.begins_with(".")) continue; if (dir->current_is_dir()) out_folders.append(file); else { String file_ext = file.get_extension(); if (_extension_filter.has(file_ext)) { _files_to_scan.push_back(path.plus_file(file)); } } } }
Dictionary InstancePlaceholder::get_stored_values(bool p_with_order) { Dictionary ret; PoolStringArray order; for (List<PropSet>::Element *E = stored_values.front(); E; E = E->next()) { ret[E->get().name] = E->get().value; if (p_with_order) order.push_back(E->get().name); }; if (p_with_order) ret[".order"] = order; return ret; };
PoolStringArray MIDIDriverCoreMidi::get_connected_inputs() { PoolStringArray list; for (int i = 0; i < connected_sources.size(); i++) { MIDIEndpointRef source = connected_sources[i]; CFStringRef ref = NULL; char name[256]; MIDIObjectGetStringProperty(source, kMIDIPropertyDisplayName, &ref); CFStringGetCString(ref, name, sizeof(name), kCFStringEncodingUTF8); CFRelease(ref); list.push_back(name); } return list; }
bool PluginScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions) const { PoolStringArray functions; if (_desc.validate) { bool ret = _desc.validate( _data, (godot_string *)&p_script, &r_line_error, &r_col_error, (godot_string *)&r_test_error, (godot_string *)&p_path, (godot_pool_string_array *)&functions); for (int i = 0; i < functions.size(); i++) { r_functions->push_back(functions[i]); } return ret; } return true; }
void ProjectManager::_files_dropped(PoolStringArray p_files, int p_screen) { Set<String> folders_set; DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); for (int i = 0; i < p_files.size(); i++) { String file = p_files[i]; folders_set.insert(da->dir_exists(file) ? file : file.get_base_dir()); } memdelete(da); if (folders_set.size()>0) { PoolStringArray folders; for (Set<String>::Element *E=folders_set.front();E;E=E->next()) { folders.append(E->get()); } bool confirm = true; if (folders.size()==1) { DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); if (dir->change_dir(folders[0])==OK) { dir->list_dir_begin(); String file = dir->get_next(); while(confirm && file!=String()) { if (!dir->current_is_dir() && file.ends_with("godot.cfg")) { confirm = false; } file = dir->get_next(); } dir->list_dir_end(); } memdelete(dir); } if (confirm) { multi_scan_ask->get_ok()->disconnect("pressed", this, "_scan_multiple_folders"); multi_scan_ask->get_ok()->connect("pressed", this, "_scan_multiple_folders", varray(folders)); multi_scan_ask->set_text(vformat(TTR("You are about the scan %s folders for existing Godot projects. Do you confirm?"), folders.size())); multi_scan_ask->popup_centered_minsize(); } else { _scan_multiple_folders(folders); } } }
Variant EditorAutoloadSettings::get_drag_data_fw(const Point2& p_point, Control *p_control) { if (autoload_cache.size() <= 1) return false; PoolStringArray autoloads; TreeItem *next = tree->get_next_selected(NULL); while (next) { autoloads.push_back(next->get_text(0)); next = tree->get_next_selected(next); } if (autoloads.size() == 0 || autoloads.size() == autoload_cache.size()) return Variant(); VBoxContainer *preview = memnew( VBoxContainer ); int max_size = MIN(PREVIEW_LIST_MAX_SIZE, autoloads.size()); for (int i = 0; i < max_size; i++) { Label *label = memnew( Label(autoloads[i]) ); label->set_self_modulate(Color(1,1,1,Math::lerp(1, 0, float(i)/PREVIEW_LIST_MAX_SIZE))); preview->add_child(label); } tree->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN); tree->set_drag_preview(preview); Dictionary drop_data; drop_data["type"] = "autoload"; drop_data["autoloads"] = autoloads; return drop_data; }
void ProjectManager::_scan_multiple_folders(PoolStringArray p_files) { for (int i = 0; i < p_files.size(); i++) { _scan_begin(p_files.get(i)); } }
void ConnectionsDock::update_tree() { tree->clear(); if (!selectedNode) return; TreeItem *root = tree->create_item(); List<MethodInfo> node_signals; selectedNode->get_signal_list(&node_signals); //node_signals.sort_custom<_ConnectionsDockMethodInfoSort>(); bool did_script = false; StringName base = selectedNode->get_class(); while (base) { List<MethodInfo> node_signals; Ref<Texture> icon; String name; if (!did_script) { Ref<Script> scr = selectedNode->get_script(); if (scr.is_valid()) { scr->get_script_signal_list(&node_signals); if (scr->get_path().is_resource_file()) name = scr->get_path().get_file(); else name = scr->get_class(); if (has_icon(scr->get_class(), "EditorIcons")) { icon = get_icon(scr->get_class(), "EditorIcons"); } } } else { ClassDB::get_signal_list(base, &node_signals, true); if (has_icon(base, "EditorIcons")) { icon = get_icon(base, "EditorIcons"); } name = base; } TreeItem *pitem = NULL; if (node_signals.size()) { pitem = tree->create_item(root); pitem->set_text(0, name); pitem->set_icon(0, icon); pitem->set_selectable(0, false); pitem->set_editable(0, false); pitem->set_custom_bg_color(0, get_color("prop_subsection", "Editor")); node_signals.sort(); } for (List<MethodInfo>::Element *E = node_signals.front(); E; E = E->next()) { MethodInfo &mi = E->get(); String signaldesc; signaldesc = mi.name + "("; PoolStringArray argnames; if (mi.arguments.size()) { signaldesc += " "; for (int i = 0; i < mi.arguments.size(); i++) { PropertyInfo &pi = mi.arguments[i]; if (i > 0) signaldesc += ", "; String tname = "var"; if (pi.type == Variant::OBJECT && pi.class_name != StringName()) { tname = pi.class_name.operator String(); } else if (pi.type != Variant::NIL) { tname = Variant::get_type_name(pi.type); } signaldesc += tname + " " + (pi.name == "" ? String("arg " + itos(i)) : pi.name); argnames.push_back(pi.name + ":" + tname); } signaldesc += " "; } signaldesc += ")"; TreeItem *item = tree->create_item(pitem); item->set_text(0, signaldesc); Dictionary sinfo; sinfo["name"] = mi.name; sinfo["args"] = argnames; item->set_metadata(0, sinfo); item->set_icon(0, get_icon("Signal", "EditorIcons")); List<Object::Connection> connections; selectedNode->get_signal_connection_list(mi.name, &connections); for (List<Object::Connection>::Element *F = connections.front(); F; F = F->next()) { Object::Connection &c = F->get(); if (!(c.flags & CONNECT_PERSIST)) continue; Node *target = Object::cast_to<Node>(c.target); if (!target) continue; String path = String(selectedNode->get_path_to(target)) + " :: " + c.method + "()"; if (c.flags & CONNECT_DEFERRED) path += " (deferred)"; if (c.flags & CONNECT_ONESHOT) path += " (oneshot)"; if (c.binds.size()) { path += " binds( "; for (int i = 0; i < c.binds.size(); i++) { if (i > 0) path += ", "; path += c.binds[i].operator String(); } path += " )"; } TreeItem *item2 = tree->create_item(item); item2->set_text(0, path); item2->set_metadata(0, c); item2->set_icon(0, get_icon("Slot", "EditorIcons")); } } if (!did_script) { did_script = true; } else { base = ClassDB::get_parent_class(base); } } connect_button->set_text(TTR("Connect")); connect_button->set_disabled(true); }
void EditorAutoloadSettings::drop_data_fw(const Point2& p_point, const Variant& p_data, Control *p_control) { TreeItem *ti = tree->get_item_at_pos(p_point); if (!ti) return; int section = tree->get_drop_section_at_pos(p_point); if (section < -1) return; String name; bool move_to_back = false; if (section < 0) { name = ti->get_text(0); } else if (ti->get_next()) { name = ti->get_next()->get_text(0); } else { name = ti->get_text(0); move_to_back = true; } int order = GlobalConfig::get_singleton()->get_order("autoload/" + name); AutoLoadInfo aux; List<AutoLoadInfo>::Element *E = NULL; if (!move_to_back) { aux.order = order; E = autoload_cache.find(aux); } Dictionary drop_data = p_data; PoolStringArray autoloads = drop_data["autoloads"]; Vector<int> orders; orders.resize(autoload_cache.size()); for (int i = 0; i < autoloads.size(); i++) { aux.order = GlobalConfig::get_singleton()->get_order("autoload/" + autoloads[i]); List<AutoLoadInfo>::Element *I = autoload_cache.find(aux); if (move_to_back) { autoload_cache.move_to_back(I); } else if (E != I) { autoload_cache.move_before(I, E); } else if (E->next()) { E = E->next(); } else { break; } } int i = 0; for (List<AutoLoadInfo>::Element *E = autoload_cache.front(); E; E = E->next()) { orders[i++] = E->get().order; } orders.sort(); UndoRedo *undo_redo = EditorNode::get_undo_redo(); undo_redo->create_action(TTR("Rearrange Autoloads")); i = 0; for (List<AutoLoadInfo>::Element *E = autoload_cache.front(); E; E = E->next()) { undo_redo->add_do_method(GlobalConfig::get_singleton(), "set_order", E->get().name, orders[i++]); undo_redo->add_undo_method(GlobalConfig::get_singleton(), "set_order", E->get().name, E->get().order); } orders.clear(); undo_redo->add_do_method(this, "update_autoload"); undo_redo->add_undo_method(this, "update_autoload"); undo_redo->add_do_method(this, "emit_signal", autoload_changed); undo_redo->add_undo_method(this, "emit_signal", autoload_changed); undo_redo->commit_action(); }
Variant _jobject_to_variant(JNIEnv *env, jobject obj) { if (obj == NULL) { return Variant(); } jclass c = env->GetObjectClass(obj); bool array; String name = _get_class_name(env, c, &array); //print_line("name is " + name + ", array "+Variant(array)); print_line("ARGNAME: " + name); if (name == "java.lang.String") { return String::utf8(env->GetStringUTFChars((jstring)obj, NULL)); }; if (name == "[Ljava.lang.String;") { jobjectArray arr = (jobjectArray)obj; int stringCount = env->GetArrayLength(arr); //print_line("String array! " + String::num(stringCount)); PoolVector<String> sarr; for (int i = 0; i < stringCount; i++) { jstring string = (jstring)env->GetObjectArrayElement(arr, i); sarr.push_back(String::utf8(env->GetStringUTFChars(string, NULL))); env->DeleteLocalRef(string); } return sarr; }; if (name == "java.lang.Boolean") { jmethodID boolValue = env->GetMethodID(c, "booleanValue", "()Z"); bool ret = env->CallBooleanMethod(obj, boolValue); return ret; }; if (name == "java.lang.Integer") { jclass nclass = env->FindClass("java/lang/Number"); jmethodID intValue = env->GetMethodID(nclass, "intValue", "()I"); int ret = env->CallIntMethod(obj, intValue); return ret; }; if (name == "[I") { jintArray arr = (jintArray)obj; int fCount = env->GetArrayLength(arr); PoolVector<int> sarr; sarr.resize(fCount); PoolVector<int>::Write w = sarr.write(); env->GetIntArrayRegion(arr, 0, fCount, w.ptr()); w = PoolVector<int>::Write(); return sarr; }; if (name == "[B") { jbyteArray arr = (jbyteArray)obj; int fCount = env->GetArrayLength(arr); PoolVector<uint8_t> sarr; sarr.resize(fCount); PoolVector<uint8_t>::Write w = sarr.write(); env->GetByteArrayRegion(arr, 0, fCount, reinterpret_cast<signed char *>(w.ptr())); w = PoolVector<uint8_t>::Write(); return sarr; }; if (name == "java.lang.Float" || name == "java.lang.Double") { jclass nclass = env->FindClass("java/lang/Number"); jmethodID doubleValue = env->GetMethodID(nclass, "doubleValue", "()D"); double ret = env->CallDoubleMethod(obj, doubleValue); return ret; }; if (name == "[D") { jdoubleArray arr = (jdoubleArray)obj; int fCount = env->GetArrayLength(arr); PoolRealArray sarr; sarr.resize(fCount); PoolRealArray::Write w = sarr.write(); for (int i = 0; i < fCount; i++) { double n; env->GetDoubleArrayRegion(arr, i, 1, &n); w.ptr()[i] = n; }; return sarr; }; if (name == "[F") { jfloatArray arr = (jfloatArray)obj; int fCount = env->GetArrayLength(arr); PoolRealArray sarr; sarr.resize(fCount); PoolRealArray::Write w = sarr.write(); for (int i = 0; i < fCount; i++) { float n; env->GetFloatArrayRegion(arr, i, 1, &n); w.ptr()[i] = n; }; return sarr; }; if (name == "[Ljava.lang.Object;") { jobjectArray arr = (jobjectArray)obj; int objCount = env->GetArrayLength(arr); Array varr; for (int i = 0; i < objCount; i++) { jobject jobj = env->GetObjectArrayElement(arr, i); Variant v = _jobject_to_variant(env, jobj); varr.push_back(v); env->DeleteLocalRef(jobj); } return varr; }; if (name == "java.util.HashMap" || name == "org.godotengine.godot.Dictionary") { Dictionary ret; jclass oclass = c; jmethodID get_keys = env->GetMethodID(oclass, "get_keys", "()[Ljava/lang/String;"); jobjectArray arr = (jobjectArray)env->CallObjectMethod(obj, get_keys); PoolStringArray keys = _jobject_to_variant(env, arr); env->DeleteLocalRef(arr); jmethodID get_values = env->GetMethodID(oclass, "get_values", "()[Ljava/lang/Object;"); arr = (jobjectArray)env->CallObjectMethod(obj, get_values); Array vals = _jobject_to_variant(env, arr); env->DeleteLocalRef(arr); //print_line("adding " + String::num(keys.size()) + " to Dictionary!"); for (int i = 0; i < keys.size(); i++) { ret[keys[i]] = vals[i]; }; return ret; }; env->DeleteLocalRef(c); return Variant(); }