1049 lines
26 KiB
C++
1049 lines
26 KiB
C++
/*************************************************************************/
|
|
/* globals.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "globals.h"
|
|
|
|
#include "os/dir_access.h"
|
|
#include "os/file_access.h"
|
|
#include "os/keyboard.h"
|
|
#include "io/marshalls.h"
|
|
#include "bind/core_bind.h"
|
|
#include "os/os.h"
|
|
#include "io/file_access_pack.h"
|
|
#include "io/file_access_network.h"
|
|
#include "variant_parser.h"
|
|
|
|
#define FORMAT_VERSION 3
|
|
|
|
GlobalConfig *GlobalConfig::singleton=NULL;
|
|
|
|
GlobalConfig *GlobalConfig::get_singleton() {
|
|
|
|
return singleton;
|
|
}
|
|
|
|
String GlobalConfig::get_resource_path() const {
|
|
|
|
return resource_path;
|
|
};
|
|
|
|
String GlobalConfig::localize_path(const String& p_path) const {
|
|
|
|
if (resource_path=="")
|
|
return p_path; //not initialied yet
|
|
|
|
if (p_path.begins_with("res://") || p_path.begins_with("user://") ||
|
|
(p_path.is_abs_path() && !p_path.begins_with(resource_path)))
|
|
return p_path.simplify_path();
|
|
|
|
|
|
DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
|
|
String path = p_path.replace("\\","/").simplify_path();
|
|
|
|
if (dir->change_dir(path)==OK) {
|
|
|
|
String cwd = dir->get_current_dir();
|
|
cwd = cwd.replace("\\","/");
|
|
|
|
memdelete(dir);
|
|
|
|
if (!cwd.begins_with(resource_path)) {
|
|
return p_path;
|
|
};
|
|
|
|
return cwd.replace_first(resource_path, "res:/");
|
|
} else {
|
|
|
|
memdelete(dir);
|
|
|
|
int sep = path.find_last("/");
|
|
if (sep == -1) {
|
|
return "res://"+path;
|
|
};
|
|
|
|
|
|
String parent = path.substr(0, sep);
|
|
|
|
String plocal = localize_path(parent);
|
|
if (plocal == "") {
|
|
return "";
|
|
};
|
|
return plocal + path.substr(sep, path.size() - sep);
|
|
};
|
|
|
|
}
|
|
|
|
void GlobalConfig::set_initial_value(const String& p_name, const Variant & p_value) {
|
|
|
|
ERR_FAIL_COND(!props.has(p_name));
|
|
props[p_name].initial=p_value;
|
|
}
|
|
|
|
|
|
String GlobalConfig::globalize_path(const String& p_path) const {
|
|
|
|
if (p_path.begins_with("res://")) {
|
|
|
|
if (resource_path != "") {
|
|
|
|
return p_path.replace("res:/",resource_path);
|
|
};
|
|
return p_path.replace("res://", "");
|
|
};
|
|
|
|
return p_path;
|
|
}
|
|
|
|
|
|
bool GlobalConfig::_set(const StringName& p_name, const Variant& p_value) {
|
|
|
|
_THREAD_SAFE_METHOD_
|
|
|
|
|
|
if (p_value.get_type()==Variant::NIL)
|
|
props.erase(p_name);
|
|
else {
|
|
if (props.has(p_name)) {
|
|
if (!props[p_name].overrided)
|
|
props[p_name].variant=p_value;
|
|
|
|
if (props[p_name].order>=NO_ORDER_BASE && registering_order) {
|
|
props[p_name].order=last_order++;
|
|
}
|
|
} else {
|
|
props[p_name]=VariantContainer(p_value,last_order++ + (registering_order?0:NO_ORDER_BASE));
|
|
}
|
|
}
|
|
|
|
if (!disable_platform_override) {
|
|
|
|
String s=String(p_name);
|
|
int sl = s.find("/");
|
|
int p = s.find(".");
|
|
if (p!=-1 && sl!=-1 && p < sl) {
|
|
|
|
Vector<String> ps = s.substr(0,sl).split(".");
|
|
String prop=s.substr(sl,s.length()-sl);
|
|
for(int i=1;i<ps.size();i++) {
|
|
|
|
if (ps[i]==OS::get_singleton()->get_name()) {
|
|
|
|
String fullprop=ps[0]+prop;
|
|
|
|
set(fullprop,p_value);
|
|
props[fullprop].overrided=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool GlobalConfig::_get(const StringName& p_name,Variant &r_ret) const {
|
|
|
|
_THREAD_SAFE_METHOD_
|
|
|
|
if (!props.has(p_name)) {
|
|
print_line("WARNING: not found: "+String(p_name));
|
|
return false;
|
|
}
|
|
r_ret=props[p_name].variant;
|
|
return true;
|
|
|
|
}
|
|
|
|
struct _VCSort {
|
|
|
|
String name;
|
|
Variant::Type type;
|
|
int order;
|
|
int flags;
|
|
|
|
bool operator<(const _VCSort& p_vcs) const{ return order==p_vcs.order?name<p_vcs.name:order< p_vcs.order; }
|
|
};
|
|
|
|
void GlobalConfig::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
_THREAD_SAFE_METHOD_
|
|
|
|
Set<_VCSort> vclist;
|
|
|
|
for(Map<StringName,VariantContainer>::Element *E=props.front();E;E=E->next()) {
|
|
|
|
const VariantContainer *v=&E->get();
|
|
|
|
if (v->hide_from_editor)
|
|
continue;
|
|
|
|
_VCSort vc;
|
|
vc.name=E->key();
|
|
vc.order=v->order;
|
|
vc.type=v->variant.get_type();
|
|
if (vc.name.begins_with("input/") || vc.name.begins_with("import/") || vc.name.begins_with("export/") || vc.name.begins_with("/remap") || vc.name.begins_with("/locale") || vc.name.begins_with("/autoload"))
|
|
vc.flags=PROPERTY_USAGE_STORAGE;
|
|
else
|
|
vc.flags=PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_STORAGE;
|
|
|
|
vclist.insert(vc);
|
|
}
|
|
|
|
for(Set<_VCSort>::Element *E=vclist.front();E;E=E->next()) {
|
|
|
|
if (custom_prop_info.has(E->get().name)) {
|
|
PropertyInfo pi=custom_prop_info[E->get().name];
|
|
pi.name=E->get().name;
|
|
pi.usage=E->get().flags;
|
|
p_list->push_back( pi );
|
|
} else
|
|
p_list->push_back( PropertyInfo(E->get().type, E->get().name,PROPERTY_HINT_NONE,"",E->get().flags) );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool GlobalConfig::_load_resource_pack(const String& p_pack) {
|
|
|
|
if (PackedData::get_singleton()->is_disabled())
|
|
return false;
|
|
|
|
bool ok = PackedData::get_singleton()->add_pack(p_pack)==OK;
|
|
|
|
if (!ok)
|
|
return false;
|
|
|
|
//if data.pck is found, all directory access will be from here
|
|
DirAccess::make_default<DirAccessPack>(DirAccess::ACCESS_RESOURCES);
|
|
using_datapack=true;
|
|
|
|
return true;
|
|
}
|
|
|
|
Error GlobalConfig::setup(const String& p_path,const String & p_main_pack) {
|
|
|
|
//an absolute mess of a function, must be cleaned up and reorganized somehow at some point
|
|
|
|
//_load_settings(p_path+"/override.cfg");
|
|
|
|
if (p_main_pack!="") {
|
|
|
|
bool ok = _load_resource_pack(p_main_pack);
|
|
ERR_FAIL_COND_V(!ok,ERR_CANT_OPEN);
|
|
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
|
|
_load_settings("res://override.cfg");
|
|
|
|
}
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
if (OS::get_singleton()->get_executable_path()!="") {
|
|
|
|
if (_load_resource_pack(OS::get_singleton()->get_executable_path())) {
|
|
|
|
if (p_path!="") {
|
|
resource_path=p_path;
|
|
} else {
|
|
DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
resource_path=d->get_current_dir();
|
|
memdelete(d);
|
|
|
|
}
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
|
|
_load_settings("res://override.cfg");
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if (FileAccessNetworkClient::get_singleton()) {
|
|
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
|
|
_load_settings("res://override.cfg");
|
|
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
if (OS::get_singleton()->get_resource_dir()!="") {
|
|
//OS will call Globals->get_resource_path which will be empty if not overriden!
|
|
//if the OS would rather use somewhere else, then it will not be empty.
|
|
resource_path=OS::get_singleton()->get_resource_dir().replace("\\","/");
|
|
if (resource_path.length() && resource_path[ resource_path.length()-1]=='/')
|
|
resource_path=resource_path.substr(0,resource_path.length()-1); // chop end
|
|
|
|
print_line("has res dir: "+resource_path);
|
|
if (!_load_resource_pack("res://data.pck"))
|
|
_load_resource_pack("res://data.zip");
|
|
// make sure this is load from the resource path
|
|
print_line("exists engine cfg? "+itos(FileAccess::exists("/godot.cfg")));
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
print_line("loaded godot.cfg");
|
|
_load_settings("res://override.cfg");
|
|
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
if (!d) {
|
|
|
|
resource_path = p_path;
|
|
|
|
} else {
|
|
|
|
d->change_dir(p_path);
|
|
|
|
String candidate = d->get_current_dir();
|
|
String current_dir = d->get_current_dir();
|
|
String exec_name = OS::get_singleton()->get_executable_path().get_file().get_basename();
|
|
bool found = false;
|
|
bool first_time=true;
|
|
|
|
while(true) {
|
|
//try to load settings in ascending through dirs shape!
|
|
|
|
//tries to open pack, but only first time
|
|
if (first_time && (_load_resource_pack(current_dir+"/"+exec_name+".pck") || _load_resource_pack(current_dir+"/"+exec_name+".zip") )) {
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
|
|
_load_settings("res://override.cfg");
|
|
found=true;
|
|
|
|
|
|
}
|
|
break;
|
|
} else if (first_time && (_load_resource_pack(current_dir+"/data.pck") || _load_resource_pack(current_dir+"/data.zip") )) {
|
|
if (_load_settings("res://godot.cfg")==OK || _load_settings_binary("res://godot.cfb")==OK) {
|
|
|
|
_load_settings("res://override.cfg");
|
|
found=true;
|
|
|
|
|
|
}
|
|
break;
|
|
} else if (_load_settings(current_dir+"/godot.cfg")==OK || _load_settings_binary(current_dir+"/godot.cfb")==OK) {
|
|
|
|
_load_settings(current_dir+"/override.cfg");
|
|
candidate=current_dir;
|
|
found=true;
|
|
break;
|
|
}
|
|
|
|
d->change_dir("..");
|
|
if (d->get_current_dir()==current_dir)
|
|
break; //not doing anything useful
|
|
current_dir=d->get_current_dir();
|
|
first_time=false;
|
|
}
|
|
|
|
|
|
resource_path=candidate;
|
|
resource_path = resource_path.replace("\\","/"); // windows path to unix path just in case
|
|
memdelete(d);
|
|
|
|
if (!found)
|
|
return ERR_FILE_NOT_FOUND;
|
|
};
|
|
|
|
|
|
if (resource_path.length() && resource_path[ resource_path.length()-1]=='/')
|
|
resource_path=resource_path.substr(0,resource_path.length()-1); // chop end
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool GlobalConfig::has(String p_var) const {
|
|
|
|
_THREAD_SAFE_METHOD_
|
|
|
|
return props.has(p_var);
|
|
}
|
|
|
|
|
|
void GlobalConfig::set_registering_order(bool p_enable) {
|
|
|
|
registering_order=p_enable;
|
|
}
|
|
|
|
Error GlobalConfig::_load_settings_binary(const String p_path) {
|
|
|
|
Error err;
|
|
FileAccess *f= FileAccess::open(p_path,FileAccess::READ,&err);
|
|
if (err!=OK) {
|
|
return err;
|
|
}
|
|
|
|
|
|
uint8_t hdr[4];
|
|
f->get_buffer(hdr,4);
|
|
if (hdr[0]!='E'|| hdr[1]!='C' || hdr[2]!='F' || hdr[3]!='G') {
|
|
|
|
memdelete(f);
|
|
ERR_EXPLAIN("Corrupted header in binary godot.cfb (not ECFG)");
|
|
ERR_FAIL_V(ERR_FILE_CORRUPT;)
|
|
}
|
|
|
|
set_registering_order(false);
|
|
|
|
uint32_t count=f->get_32();
|
|
|
|
for(uint32_t i=0;i<count;i++) {
|
|
|
|
uint32_t slen=f->get_32();
|
|
CharString cs;
|
|
cs.resize(slen+1);
|
|
cs[slen]=0;
|
|
f->get_buffer((uint8_t*)cs.ptr(),slen);
|
|
String key;
|
|
key.parse_utf8(cs.ptr());
|
|
|
|
uint32_t vlen=f->get_32();
|
|
Vector<uint8_t> d;
|
|
d.resize(vlen);
|
|
f->get_buffer(d.ptr(),vlen);
|
|
Variant value;
|
|
Error err = decode_variant(value,d.ptr(),d.size());
|
|
ERR_EXPLAIN("Error decoding property: "+key);
|
|
ERR_CONTINUE(err!=OK);
|
|
set(key,value);
|
|
|
|
}
|
|
|
|
set_registering_order(true);
|
|
|
|
|
|
return OK;
|
|
}
|
|
Error GlobalConfig::_load_settings(const String p_path) {
|
|
|
|
|
|
|
|
Error err;
|
|
FileAccess *f= FileAccess::open(p_path,FileAccess::READ,&err);
|
|
|
|
if (!f)
|
|
return ERR_CANT_OPEN;
|
|
|
|
VariantParser::StreamFile stream;
|
|
stream.f=f;
|
|
|
|
String assign;
|
|
Variant value;
|
|
VariantParser::Tag next_tag;
|
|
|
|
int lines=0;
|
|
String error_text;
|
|
|
|
String section;
|
|
|
|
while(true) {
|
|
|
|
assign=Variant();
|
|
next_tag.fields.clear();
|
|
next_tag.name=String();
|
|
|
|
err = VariantParser::parse_tag_assign_eof(&stream,lines,error_text,next_tag,assign,value,NULL,true);
|
|
if (err==ERR_FILE_EOF) {
|
|
memdelete(f);
|
|
return OK;
|
|
}
|
|
else if (err!=OK) {
|
|
ERR_PRINTS("GlobalConfig::load - "+p_path+":"+itos(lines)+" error: "+error_text);
|
|
memdelete(f);
|
|
return err;
|
|
}
|
|
|
|
if (assign!=String()) {
|
|
if (section==String() && assign=="config_version") {
|
|
int config_version = value;
|
|
if (config_version > FORMAT_VERSION) {
|
|
memdelete(f);
|
|
ERR_FAIL_COND_V(config_version > FORMAT_VERSION,ERR_FILE_CANT_OPEN);
|
|
}
|
|
|
|
}
|
|
set(section+"/"+assign,value);
|
|
} else if (next_tag.name!=String()) {
|
|
section=next_tag.name;
|
|
}
|
|
}
|
|
|
|
memdelete(f);
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
int GlobalConfig::get_order(const String& p_name) const {
|
|
|
|
ERR_FAIL_COND_V(!props.has(p_name),-1);
|
|
return props[p_name].order;
|
|
}
|
|
|
|
|
|
void GlobalConfig::set_order(const String& p_name, int p_order){
|
|
|
|
ERR_FAIL_COND(!props.has(p_name));
|
|
props[p_name].order=p_order;
|
|
}
|
|
|
|
void GlobalConfig::clear(const String& p_name) {
|
|
|
|
ERR_FAIL_COND(!props.has(p_name));
|
|
props.erase(p_name);
|
|
}
|
|
|
|
Error GlobalConfig::save() {
|
|
|
|
return save_custom(get_resource_path()+"/godot.cfg");
|
|
}
|
|
|
|
Error GlobalConfig::_save_settings_binary(const String& p_file,const Map<String,List<String> > &props,const CustomMap& p_custom) {
|
|
|
|
|
|
Error err;
|
|
FileAccess *file = FileAccess::open(p_file,FileAccess::WRITE,&err);
|
|
if (err!=OK) {
|
|
|
|
ERR_EXPLAIN("Coudln't save godot.cfb at "+p_file);
|
|
ERR_FAIL_COND_V(err,err)
|
|
}
|
|
|
|
uint8_t hdr[4]={'E','C','F','G'};
|
|
file->store_buffer(hdr,4);
|
|
|
|
int count=0;
|
|
|
|
for(Map<String,List<String> >::Element *E=props.front();E;E=E->next()) {
|
|
|
|
for(List<String>::Element *F=E->get().front();F;F=F->next()) {
|
|
|
|
count++;
|
|
}
|
|
}
|
|
|
|
file->store_32(count); //store how many properties are saved
|
|
|
|
|
|
for(Map<String,List<String> >::Element *E=props.front();E;E=E->next()) {
|
|
|
|
for(List<String>::Element *F=E->get().front();F;F=F->next()) {
|
|
|
|
String key = F->get();
|
|
if (E->key()!="")
|
|
key=E->key()+"/"+key;
|
|
Variant value;
|
|
if (p_custom.has(key))
|
|
value=p_custom[key];
|
|
else
|
|
value = get(key);
|
|
|
|
file->store_32(key.length());
|
|
file->store_string(key);
|
|
|
|
int len;
|
|
Error err = encode_variant(value,NULL,len);
|
|
if (err!=OK)
|
|
memdelete(file);
|
|
ERR_FAIL_COND_V( err != OK, ERR_INVALID_DATA );
|
|
|
|
Vector<uint8_t> buff;
|
|
buff.resize(len);
|
|
|
|
err = encode_variant(value,&buff[0],len);
|
|
if (err!=OK)
|
|
memdelete(file);
|
|
ERR_FAIL_COND_V( err != OK, ERR_INVALID_DATA );
|
|
file->store_32(len);
|
|
file->store_buffer(buff.ptr(),buff.size());
|
|
}
|
|
}
|
|
|
|
file->close();
|
|
memdelete(file);
|
|
|
|
|
|
return OK;
|
|
}
|
|
|
|
|
|
Error GlobalConfig::_save_settings_text(const String& p_file,const Map<String,List<String> > &props,const CustomMap& p_custom) {
|
|
|
|
Error err;
|
|
FileAccess *file = FileAccess::open(p_file,FileAccess::WRITE,&err);
|
|
|
|
if (err) {
|
|
ERR_EXPLAIN("Coudln't save godot.cfg - "+p_file);
|
|
ERR_FAIL_COND_V(err,err)
|
|
}
|
|
|
|
file->store_string("config_version="+itos(FORMAT_VERSION)+"\n");
|
|
|
|
|
|
for(Map<String,List<String> >::Element *E=props.front();E;E=E->next()) {
|
|
|
|
if (E!=props.front())
|
|
file->store_string("\n");
|
|
|
|
if (E->key()!="")
|
|
file->store_string("["+E->key()+"]\n\n");
|
|
for(List<String>::Element *F=E->get().front();F;F=F->next()) {
|
|
|
|
String key = F->get();
|
|
if (E->key()!="")
|
|
key=E->key()+"/"+key;
|
|
Variant value;
|
|
if (p_custom.has(key))
|
|
value=p_custom[key];
|
|
else
|
|
value = get(key);
|
|
|
|
|
|
String vstr;
|
|
VariantWriter::write_to_string(value,vstr);
|
|
file->store_string(F->get()+"="+vstr+"\n");
|
|
|
|
}
|
|
}
|
|
|
|
file->close();
|
|
memdelete(file);
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error GlobalConfig::_save_custom_bnd(const String &p_file) { // add other params as dictionary and array?
|
|
|
|
return save_custom(p_file);
|
|
};
|
|
|
|
Error GlobalConfig::save_custom(const String& p_path,const CustomMap& p_custom,const Set<String>& p_ignore_masks) {
|
|
|
|
ERR_FAIL_COND_V(p_path=="",ERR_INVALID_PARAMETER);
|
|
|
|
Set<_VCSort> vclist;
|
|
|
|
for(Map<StringName,VariantContainer>::Element *G=props.front();G;G=G->next()) {
|
|
|
|
const VariantContainer *v=&G->get();
|
|
|
|
if (v->hide_from_editor)
|
|
continue;
|
|
|
|
if (p_custom.has(G->key()))
|
|
continue;
|
|
|
|
bool discard=false;
|
|
|
|
for(const Set<String>::Element *E=p_ignore_masks.front();E;E=E->next()) {
|
|
|
|
if ( String(G->key()).match(E->get())) {
|
|
discard=true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (discard)
|
|
continue;
|
|
|
|
_VCSort vc;
|
|
vc.name=G->key();//*k;
|
|
vc.order=v->order;
|
|
vc.type=v->variant.get_type();
|
|
vc.flags=PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_STORAGE;
|
|
if (v->variant==v->initial)
|
|
continue;
|
|
|
|
|
|
vclist.insert(vc);
|
|
}
|
|
|
|
for(const Map<String,Variant>::Element *E=p_custom.front();E;E=E->next()) {
|
|
|
|
|
|
_VCSort vc;
|
|
vc.name=E->key();
|
|
vc.order=0xFFFFFFF;
|
|
vc.type=E->get().get_type();
|
|
vc.flags=PROPERTY_USAGE_STORAGE;
|
|
vclist.insert(vc);
|
|
}
|
|
|
|
Map<String,List<String> > props;
|
|
|
|
for(Set<_VCSort>::Element *E=vclist.front();E;E=E->next()) {
|
|
|
|
String category = E->get().name;
|
|
String name = E->get().name;
|
|
|
|
int div = category.find("/");
|
|
|
|
if (div<0)
|
|
category="";
|
|
else {
|
|
|
|
category=category.substr(0,div);
|
|
name=name.substr(div+1,name.size());
|
|
}
|
|
props[category].push_back(name);
|
|
}
|
|
|
|
|
|
|
|
if (p_path.ends_with(".cfg"))
|
|
return _save_settings_text(p_path,props,p_custom);
|
|
else if (p_path.ends_with(".cfb"))
|
|
return _save_settings_binary(p_path,props,p_custom);
|
|
else {
|
|
|
|
ERR_EXPLAIN("Unknown config file format: "+p_path);
|
|
ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
|
|
}
|
|
|
|
return OK;
|
|
|
|
#if 0
|
|
Error err = file->open(dst_file,FileAccess::WRITE);
|
|
if (err) {
|
|
memdelete(file);
|
|
ERR_EXPLAIN("Coudln't save godot.cfg");
|
|
ERR_FAIL_COND_V(err,err)
|
|
}
|
|
|
|
|
|
for(Map<String,List<String> >::Element *E=props.front();E;E=E->next()) {
|
|
|
|
if (E!=props.front())
|
|
file->store_string("\n");
|
|
|
|
if (E->key()!="")
|
|
file->store_string("["+E->key()+"]\n\n");
|
|
for(List<String>::Element *F=E->get().front();F;F=F->next()) {
|
|
|
|
String key = F->get();
|
|
if (E->key()!="")
|
|
key=E->key()+"/"+key;
|
|
Variant value;
|
|
|
|
if (p_custom.has(key))
|
|
value=p_custom[key];
|
|
else
|
|
value = get(key);
|
|
|
|
file->store_string(F->get()+"="+_encode_variant(value)+"\n");
|
|
|
|
}
|
|
}
|
|
|
|
file->close();
|
|
memdelete(file);
|
|
|
|
|
|
return OK;
|
|
#endif
|
|
}
|
|
|
|
Variant _GLOBAL_DEF( const String& p_var, const Variant& p_default) {
|
|
|
|
if (GlobalConfig::get_singleton()->has(p_var)) {
|
|
GlobalConfig::get_singleton()->set_initial_value(p_var,p_default);
|
|
return GlobalConfig::get_singleton()->get(p_var);
|
|
}
|
|
GlobalConfig::get_singleton()->set(p_var,p_default);
|
|
GlobalConfig::get_singleton()->set_initial_value(p_var,p_default);
|
|
return p_default;
|
|
|
|
}
|
|
|
|
void GlobalConfig::add_singleton(const Singleton &p_singleton) {
|
|
|
|
singletons.push_back(p_singleton);
|
|
singleton_ptrs[p_singleton.name]=p_singleton.ptr;
|
|
}
|
|
|
|
Object* GlobalConfig::get_singleton_object(const String& p_name) const {
|
|
|
|
|
|
const Map<StringName,Object*>::Element *E=singleton_ptrs.find(p_name);
|
|
if (!E)
|
|
return NULL;
|
|
else
|
|
return E->get();
|
|
|
|
};
|
|
|
|
bool GlobalConfig::has_singleton(const String& p_name) const {
|
|
|
|
return get_singleton_object(p_name) != NULL;
|
|
};
|
|
|
|
void GlobalConfig::get_singletons(List<Singleton> *p_singletons) {
|
|
|
|
for(List<Singleton>::Element *E=singletons.front();E;E=E->next())
|
|
p_singletons->push_back(E->get());
|
|
}
|
|
|
|
Vector<String> GlobalConfig::get_optimizer_presets() const {
|
|
|
|
List<PropertyInfo> pi;
|
|
GlobalConfig::get_singleton()->get_property_list(&pi);
|
|
Vector<String> names;
|
|
|
|
for (List<PropertyInfo>::Element *E=pi.front();E;E=E->next()) {
|
|
|
|
if (!E->get().name.begins_with("optimizer_presets/"))
|
|
continue;
|
|
names.push_back(E->get().name.get_slicec('/',1));
|
|
}
|
|
|
|
names.sort();
|
|
|
|
return names;
|
|
|
|
}
|
|
|
|
void GlobalConfig::_add_property_info_bind(const Dictionary& p_info) {
|
|
|
|
ERR_FAIL_COND(!p_info.has("name"));
|
|
ERR_FAIL_COND(!p_info.has("type"));
|
|
|
|
PropertyInfo pinfo;
|
|
pinfo.name = p_info["name"];
|
|
ERR_FAIL_COND(!props.has(pinfo.name));
|
|
pinfo.type = Variant::Type(p_info["type"].operator int());
|
|
ERR_FAIL_INDEX(pinfo.type, Variant::VARIANT_MAX);
|
|
|
|
if (p_info.has("hint"))
|
|
pinfo.hint = PropertyHint(p_info["hint"].operator int());
|
|
if (p_info.has("hint_string"))
|
|
pinfo.hint_string = p_info["hint_string"];
|
|
|
|
set_custom_property_info(pinfo.name, pinfo);
|
|
}
|
|
|
|
void GlobalConfig::set_custom_property_info(const String& p_prop,const PropertyInfo& p_info) {
|
|
|
|
ERR_FAIL_COND(!props.has(p_prop));
|
|
custom_prop_info[p_prop]=p_info;
|
|
custom_prop_info[p_prop].name=p_prop;
|
|
|
|
}
|
|
|
|
void GlobalConfig::set_disable_platform_override(bool p_disable) {
|
|
|
|
disable_platform_override=p_disable;
|
|
}
|
|
|
|
bool GlobalConfig::is_using_datapack() const {
|
|
|
|
return using_datapack;
|
|
}
|
|
|
|
bool GlobalConfig::property_can_revert(const String& p_name) {
|
|
|
|
if (!props.has(p_name))
|
|
return false;
|
|
|
|
return props[p_name].initial!=props[p_name].variant;
|
|
|
|
}
|
|
|
|
Variant GlobalConfig::property_get_revert(const String& p_name) {
|
|
|
|
if (!props.has(p_name))
|
|
return Variant();
|
|
|
|
return props[p_name].initial;
|
|
}
|
|
|
|
void GlobalConfig::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("has","name"),&GlobalConfig::has);
|
|
ClassDB::bind_method(D_METHOD("set_order","name","pos"),&GlobalConfig::set_order);
|
|
ClassDB::bind_method(D_METHOD("get_order","name"),&GlobalConfig::get_order);
|
|
ClassDB::bind_method(D_METHOD("set_initial_value","name","value"),&GlobalConfig::set_initial_value);
|
|
ClassDB::bind_method(D_METHOD("add_property_info", "hint"),&GlobalConfig::_add_property_info_bind);
|
|
ClassDB::bind_method(D_METHOD("clear","name"),&GlobalConfig::clear);
|
|
ClassDB::bind_method(D_METHOD("localize_path","path"),&GlobalConfig::localize_path);
|
|
ClassDB::bind_method(D_METHOD("globalize_path","path"),&GlobalConfig::globalize_path);
|
|
ClassDB::bind_method(D_METHOD("save"),&GlobalConfig::save);
|
|
ClassDB::bind_method(D_METHOD("has_singleton","name"),&GlobalConfig::has_singleton);
|
|
ClassDB::bind_method(D_METHOD("get_singleton","name"),&GlobalConfig::get_singleton_object);
|
|
ClassDB::bind_method(D_METHOD("load_resource_pack","pack"),&GlobalConfig::_load_resource_pack);
|
|
ClassDB::bind_method(D_METHOD("property_can_revert","name"),&GlobalConfig::property_can_revert);
|
|
ClassDB::bind_method(D_METHOD("property_get_revert","name"),&GlobalConfig::property_get_revert);
|
|
|
|
ClassDB::bind_method(D_METHOD("save_custom","file"),&GlobalConfig::_save_custom_bnd);
|
|
|
|
}
|
|
|
|
GlobalConfig::GlobalConfig() {
|
|
|
|
|
|
singleton=this;
|
|
last_order=0;
|
|
disable_platform_override=false;
|
|
registering_order=true;
|
|
|
|
|
|
Array va;
|
|
InputEvent key;
|
|
key.type=InputEvent::KEY;
|
|
InputEvent joyb;
|
|
joyb.type=InputEvent::JOYPAD_BUTTON;
|
|
|
|
|
|
GLOBAL_DEF("application/name","" );
|
|
GLOBAL_DEF("application/main_scene","");
|
|
custom_prop_info["application/main_scene"]=PropertyInfo(Variant::STRING,"application/main_scene",PROPERTY_HINT_FILE,"tscn,scn,xscn,xml,res");
|
|
GLOBAL_DEF("application/disable_stdout",false);
|
|
GLOBAL_DEF("application/disable_stderr",false);
|
|
GLOBAL_DEF("application/use_shared_user_dir",true);
|
|
|
|
|
|
key.key.scancode=KEY_RETURN;
|
|
va.push_back(key);
|
|
key.key.scancode=KEY_ENTER;
|
|
va.push_back(key);
|
|
key.key.scancode=KEY_SPACE;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_BUTTON_0;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_accept",va);
|
|
input_presets.push_back("input/ui_accept");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_SPACE;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_BUTTON_3;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_select",va);
|
|
input_presets.push_back("input/ui_select");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_ESCAPE;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_BUTTON_1;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_cancel",va);
|
|
input_presets.push_back("input/ui_cancel");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_TAB;
|
|
va.push_back(key);
|
|
GLOBAL_DEF("input/ui_focus_next",va);
|
|
input_presets.push_back("input/ui_focus_next");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_TAB;
|
|
key.key.mod.shift=true;
|
|
va.push_back(key);
|
|
GLOBAL_DEF("input/ui_focus_prev",va);
|
|
input_presets.push_back("input/ui_focus_prev");
|
|
key.key.mod.shift=false;
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_LEFT;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_DPAD_LEFT;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_left",va);
|
|
input_presets.push_back("input/ui_left");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_RIGHT;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_DPAD_RIGHT;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_right",va);
|
|
input_presets.push_back("input/ui_right");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_UP;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_DPAD_UP;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_up",va);
|
|
input_presets.push_back("input/ui_up");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_DOWN;
|
|
va.push_back(key);
|
|
joyb.joy_button.button_index=JOY_DPAD_DOWN;
|
|
va.push_back(joyb);
|
|
GLOBAL_DEF("input/ui_down",va);
|
|
input_presets.push_back("input/ui_down");
|
|
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_PAGEUP;
|
|
va.push_back(key);
|
|
GLOBAL_DEF("input/ui_page_up",va);
|
|
input_presets.push_back("input/ui_page_up");
|
|
|
|
va=Array();
|
|
key.key.scancode=KEY_PAGEDOWN;
|
|
va.push_back(key);
|
|
GLOBAL_DEF("input/ui_page_down",va);
|
|
input_presets.push_back("input/ui_page_down");
|
|
|
|
//GLOBAL_DEF("display/handheld/orientation", "landscape");
|
|
|
|
|
|
custom_prop_info["display/handheld/orientation"]=PropertyInfo(Variant::STRING,"display/handheld/orientation",PROPERTY_HINT_ENUM,"landscape,portrait,reverse_landscape,reverse_portrait,sensor_landscape,sensor_portrait,sensor");
|
|
custom_prop_info["rendering/threads/thread_model"]=PropertyInfo(Variant::INT,"rendering/threads/thread_model",PROPERTY_HINT_ENUM,"Single-Unsafe,Single-Safe,Multi-Threaded");
|
|
custom_prop_info["physics/2d/thread_model"]=PropertyInfo(Variant::INT,"physics/2d/thread_model",PROPERTY_HINT_ENUM,"Single-Unsafe,Single-Safe,Multi-Threaded");
|
|
|
|
GLOBAL_DEF("debug/profiler/max_functions",16384);
|
|
using_datapack=false;
|
|
}
|
|
|
|
|
|
GlobalConfig::~GlobalConfig() {
|
|
|
|
singleton=NULL;
|
|
}
|
|
|
|
|