void ClassDB::get_method_list(StringName p_class, List<MethodInfo> *p_methods, bool p_no_inheritance, bool p_exclude_from_properties) { OBJTYPE_RLOCK; ClassInfo *type = classes.getptr(p_class); while (type) { if (type->disabled) { if (p_no_inheritance) break; type = type->inherits_ptr; continue; } #ifdef DEBUG_METHODS_ENABLED for (List<MethodInfo>::Element *E = type->virtual_methods.front(); E; E = E->next()) { p_methods->push_back(E->get()); } for (List<StringName>::Element *E = type->method_order.front(); E; E = E->next()) { MethodBind *method = type->method_map.get(E->get()); MethodInfo minfo; minfo.name = E->get(); minfo.id = method->get_method_id(); if (p_exclude_from_properties && type->methods_in_properties.has(minfo.name)) continue; for (int i = 0; i < method->get_argument_count(); i++) { //Variant::Type t=method->get_argument_type(i); minfo.arguments.push_back(method->get_argument_info(i)); } minfo.return_val = method->get_return_info(); minfo.flags = method->get_hint_flags(); for (int i = 0; i < method->get_argument_count(); i++) { if (method->has_default_argument(i)) minfo.default_arguments.push_back(method->get_default_argument(i)); } p_methods->push_back(minfo); } #else const StringName *K = NULL; while ((K = type->method_map.next(K))) { MethodBind *m = type->method_map[*K]; MethodInfo mi; mi.name = m->get_name(); p_methods->push_back(mi); } #endif if (p_no_inheritance) break; type = type->inherits_ptr; } }
void DocData::generate(bool p_basic_types) { List<StringName> classes; ClassDB::get_class_list(&classes); classes.sort_custom<StringName::AlphCompare>(); bool skip_setter_getter_methods = true; while (classes.size()) { Set<StringName> setters_getters; String name = classes.front()->get(); String cname = name; if (cname.begins_with("_")) //proxy class cname = cname.substr(1, name.length()); class_list[cname] = ClassDoc(); ClassDoc &c = class_list[cname]; c.name = cname; c.inherits = ClassDB::get_parent_class(name); c.category = ClassDB::get_category(name); List<PropertyInfo> properties; ClassDB::get_property_list(name, &properties, true); for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) { if (E->get().usage & PROPERTY_USAGE_GROUP || E->get().usage & PROPERTY_USAGE_CATEGORY || E->get().usage & PROPERTY_USAGE_INTERNAL) continue; PropertyDoc prop; StringName setter = ClassDB::get_property_setter(name, E->get().name); StringName getter = ClassDB::get_property_getter(name, E->get().name); prop.name = E->get().name; prop.setter = setter; prop.getter = getter; bool found_type = false; if (getter != StringName()) { MethodBind *mb = ClassDB::get_method(name, getter); if (mb) { PropertyInfo retinfo = mb->get_return_info(); found_type = true; if (retinfo.type == Variant::INT && retinfo.usage & PROPERTY_USAGE_CLASS_IS_ENUM) { prop.enumeration = retinfo.class_name; prop.type = "int"; } else if (retinfo.class_name != StringName()) { prop.type = retinfo.class_name; } else if (retinfo.hint == PROPERTY_HINT_RESOURCE_TYPE) { prop.type = retinfo.hint_string; } else if (retinfo.type == Variant::NIL && retinfo.usage & PROPERTY_USAGE_NIL_IS_VARIANT) { prop.type = "Variant"; } else if (retinfo.type == Variant::NIL) { prop.type = "void"; } else { prop.type = Variant::get_type_name(retinfo.type); } } setters_getters.insert(getter); } if (setter != StringName()) { setters_getters.insert(setter); } if (!found_type) { if (E->get().type == Variant::OBJECT && E->get().hint == PROPERTY_HINT_RESOURCE_TYPE) prop.type = E->get().hint_string; else prop.type = Variant::get_type_name(E->get().type); } c.properties.push_back(prop); } List<MethodInfo> method_list; ClassDB::get_method_list(name, &method_list, true); method_list.sort(); for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) { if (E->get().name == "" || (E->get().name[0] == '_' && !(E->get().flags & METHOD_FLAG_VIRTUAL))) continue; //hidden, don't count if (skip_setter_getter_methods && setters_getters.has(E->get().name) && E->get().name.find("/") == -1) continue; MethodDoc method; method.name = E->get().name; if (E->get().flags & METHOD_FLAG_VIRTUAL) method.qualifiers = "virtual"; if (E->get().flags & METHOD_FLAG_CONST) { if (method.qualifiers != "") method.qualifiers += " "; method.qualifiers += "const"; } else if (E->get().flags & METHOD_FLAG_VARARG) { if (method.qualifiers != "") method.qualifiers += " "; method.qualifiers += "vararg"; } for (int i = -1; i < E->get().arguments.size(); i++) { if (i == -1) { #ifdef DEBUG_METHODS_ENABLED return_doc_from_retinfo(method, E->get().return_val); #endif } else { const PropertyInfo &arginfo = E->get().arguments[i]; ArgumentDoc argument; argument_doc_from_arginfo(argument, arginfo); int darg_idx = i - (E->get().arguments.size() - E->get().default_arguments.size()); if (darg_idx >= 0) { Variant default_arg = E->get().default_arguments[darg_idx]; argument.default_value = default_arg.get_construct_string(); } method.arguments.push_back(argument); } /* String hint; switch(arginfo.hint) { case PROPERTY_HINT_DIR: hint="A directory."; break; case PROPERTY_HINT_RANGE: hint="Range - min: "+arginfo.hint_string.get_slice(",",0)+" max: "+arginfo.hint_string.get_slice(",",1)+" step: "+arginfo.hint_string.get_slice(",",2); break; case PROPERTY_HINT_ENUM: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(j); } break; case PROPERTY_HINT_LENGTH: hint="Length: "+arginfo.hint_string; break; case PROPERTY_HINT_FLAGS: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(1<<j); } break; case PROPERTY_HINT_FILE: hint="A file:"; break; //case PROPERTY_HINT_RESOURCE_TYPE: hint="Type: "+arginfo.hint_string; break; }; if (hint!="") _write_string(f,4,hint); */ } c.methods.push_back(method); } List<MethodInfo> signal_list; ClassDB::get_signal_list(name, &signal_list, true); if (signal_list.size()) { for (List<MethodInfo>::Element *EV = signal_list.front(); EV; EV = EV->next()) { MethodDoc signal; signal.name = EV->get().name; for (int i = 0; i < EV->get().arguments.size(); i++) { PropertyInfo arginfo = EV->get().arguments[i]; ArgumentDoc argument; argument.name = arginfo.name; argument.type = Variant::get_type_name(arginfo.type); signal.arguments.push_back(argument); } c.signals.push_back(signal); } } List<String> constant_list; ClassDB::get_integer_constant_list(name, &constant_list, true); for (List<String>::Element *E = constant_list.front(); E; E = E->next()) { ConstantDoc constant; constant.name = E->get(); constant.value = itos(ClassDB::get_integer_constant(name, E->get())); constant.enumeration = ClassDB::get_integer_constant_enum(name, E->get()); c.constants.push_back(constant); } //theme stuff { List<StringName> l; Theme::get_default()->get_constant_list(cname, &l); for (List<StringName>::Element *E = l.front(); E; E = E->next()) { PropertyDoc pd; pd.name = E->get(); pd.type = "int"; c.theme_properties.push_back(pd); } l.clear(); Theme::get_default()->get_color_list(cname, &l); for (List<StringName>::Element *E = l.front(); E; E = E->next()) { PropertyDoc pd; pd.name = E->get(); pd.type = "Color"; c.theme_properties.push_back(pd); } l.clear(); Theme::get_default()->get_icon_list(cname, &l); for (List<StringName>::Element *E = l.front(); E; E = E->next()) { PropertyDoc pd; pd.name = E->get(); pd.type = "Texture"; c.theme_properties.push_back(pd); } l.clear(); Theme::get_default()->get_font_list(cname, &l); for (List<StringName>::Element *E = l.front(); E; E = E->next()) { PropertyDoc pd; pd.name = E->get(); pd.type = "Font"; c.theme_properties.push_back(pd); } l.clear(); Theme::get_default()->get_stylebox_list(cname, &l); for (List<StringName>::Element *E = l.front(); E; E = E->next()) { PropertyDoc pd; pd.name = E->get(); pd.type = "StyleBox"; c.theme_properties.push_back(pd); } } classes.pop_front(); } { //so it can be documented that it does not exist class_list["Variant"] = ClassDoc(); class_list["Variant"].name = "Variant"; } if (!p_basic_types) return; for (int i = 0; i < Variant::VARIANT_MAX; i++) { if (i == Variant::OBJECT) continue; //use the core type instead String cname = Variant::get_type_name(Variant::Type(i)); class_list[cname] = ClassDoc(); ClassDoc &c = class_list[cname]; c.name = cname; c.category = "Built-In Types"; Variant::CallError cerror; Variant v = Variant::construct(Variant::Type(i), NULL, 0, cerror); List<MethodInfo> method_list; v.get_method_list(&method_list); method_list.sort(); Variant::get_constructor_list(Variant::Type(i), &method_list); for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) { MethodInfo &mi = E->get(); MethodDoc method; method.name = mi.name; for (int i = 0; i < mi.arguments.size(); i++) { PropertyInfo arginfo = mi.arguments[i]; ArgumentDoc ad; ad.name = arginfo.name; if (arginfo.type == Variant::NIL) ad.type = "var"; else ad.type = Variant::get_type_name(arginfo.type); int defarg = mi.default_arguments.size() - mi.arguments.size() + i; if (defarg >= 0) ad.default_value = mi.default_arguments[defarg]; method.arguments.push_back(ad); } if (mi.return_val.type == Variant::NIL) { if (mi.return_val.name != "") method.return_type = "var"; } else { method.return_type = Variant::get_type_name(mi.return_val.type); } c.methods.push_back(method); } List<PropertyInfo> properties; v.get_property_list(&properties); for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) { PropertyInfo pi = E->get(); PropertyDoc property; property.name = pi.name; property.type = Variant::get_type_name(pi.type); c.properties.push_back(property); } List<StringName> constants; Variant::get_numeric_constants_for_type(Variant::Type(i), &constants); for (List<StringName>::Element *E = constants.front(); E; E = E->next()) { ConstantDoc constant; constant.name = E->get(); constant.value = itos(Variant::get_numeric_constant_value(Variant::Type(i), E->get())); c.constants.push_back(constant); } } //built in constants and functions { String cname = "@GlobalScope"; class_list[cname] = ClassDoc(); ClassDoc &c = class_list[cname]; c.name = cname; for (int i = 0; i < GlobalConstants::get_global_constant_count(); i++) { ConstantDoc cd; cd.name = GlobalConstants::get_global_constant_name(i); cd.value = itos(GlobalConstants::get_global_constant_value(i)); cd.enumeration = GlobalConstants::get_global_constant_enum(i); c.constants.push_back(cd); } List<Engine::Singleton> singletons; Engine::get_singleton()->get_singletons(&singletons); //servers (this is kind of hackish) for (List<Engine::Singleton>::Element *E = singletons.front(); E; E = E->next()) { PropertyDoc pd; Engine::Singleton &s = E->get(); pd.name = s.name; pd.type = s.ptr->get_class(); while (String(ClassDB::get_parent_class(pd.type)) != "Object") pd.type = ClassDB::get_parent_class(pd.type); if (pd.type.begins_with("_")) pd.type = pd.type.substr(1, pd.type.length()); c.properties.push_back(pd); } } //built in script reference { for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptLanguage *lang = ScriptServer::get_language(i); String cname = "@" + lang->get_name(); class_list[cname] = ClassDoc(); ClassDoc &c = class_list[cname]; c.name = cname; List<MethodInfo> minfo; lang->get_public_functions(&minfo); for (List<MethodInfo>::Element *E = minfo.front(); E; E = E->next()) { MethodInfo &mi = E->get(); MethodDoc md; md.name = mi.name; if (mi.flags & METHOD_FLAG_VARARG) { if (md.qualifiers != "") md.qualifiers += " "; md.qualifiers += "vararg"; } return_doc_from_retinfo(md, mi.return_val); for (int i = 0; i < mi.arguments.size(); i++) { ArgumentDoc ad; argument_doc_from_arginfo(ad, mi.arguments[i]); int darg_idx = i - (mi.arguments.size() - mi.default_arguments.size()); if (darg_idx >= 0) { Variant default_arg = E->get().default_arguments[darg_idx]; ad.default_value = default_arg.get_construct_string(); } md.arguments.push_back(ad); } c.methods.push_back(md); } List<Pair<String, Variant> > cinfo; lang->get_public_constants(&cinfo); for (List<Pair<String, Variant> >::Element *E = cinfo.front(); E; E = E->next()) { ConstantDoc cd; cd.name = E->get().first; cd.value = E->get().second; c.constants.push_back(cd); } } } }