text: /*************************************************************************/
  /*  globals.cpp                                                          */
  /*************************************************************************/
  /*                       This file is part of:                           */
  /*                           GODOT ENGINE                                */
  /*                    http://www.godotengine.org                         */
  /*************************************************************************/
  /* Copyright (c) 2007-2015 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"
  
  Globals *Globals::singleton=NULL;
  
  Globals *Globals::get_singleton() {
  	
  	return singleton;
  }
  
  String Globals::get_resource_path() const {
  
  	return resource_path;
  };
  
  String Globals::localize_path(const String& p_path) const {
  
  	if (resource_path=="")
  		return p_path; //not initialied yet
  
  	if (p_path.begins_with("res://"))
  		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 Globals::set_persisting(const String& p_name, bool p_persist) {
  
  	ERR_FAIL_COND(!props.has(p_name));
  	props[p_name].persist=p_persist;
  }
  
  bool Globals::is_persisting(const String& p_name) const {
  
  	ERR_FAIL_COND_V(!props.has(p_name),false);
  	return props[p_name].persist;
  
  }
  
  
  String Globals::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 Globals::_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;
  		} else {
  			props[p_name]=VariantContainer(p_value,last_order++);
  		}
  	}
  
  	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 Globals::_get(const StringName& p_name,Variant &r_ret) const {
  
  	_THREAD_SAFE_METHOD_
  
  	if (!props.has(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 Globals::_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_CHECKABLE|PROPERTY_USAGE_STORAGE;
  		else
  			vc.flags=PROPERTY_USAGE_CHECKABLE|PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_STORAGE;
  
  		if (v->persist) {
  			vc.flags|=PROPERTY_USAGE_CHECKED;
  		}
  
  		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 Globals::_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 Globals::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://engine.cfg")==OK || _load_settings_binary("res://engine.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://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
  
  				_load_settings("res://override.cfg");
  
  			}
  
  
  
  			return OK;
  		}
  
  	}
  	
  
  	if (FileAccessNetworkClient::get_singleton()) {
  
  		if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.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.pcz");
  		// make sure this is load from the resource path
  		print_line("exists engine cfg? "+itos(FileAccess::exists("/engine.cfg")));
  		if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
  			print_line("loaded engine.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();
  		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+"/data.pck") || _load_resource_pack(current_dir+"/data.pcz") )) {
  				if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
  
  					_load_settings("res://override.cfg");
  					found=true;
  
  
  				}
  				break;
  			} else if (_load_settings(current_dir+"/engine.cfg")==OK || _load_settings_binary(current_dir+"/engine.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 Globals::has(String p_var) const {
  	
  	_THREAD_SAFE_METHOD_
  
  	return props.has(p_var);
  }
  
  static Vector<String> _decode_params(const String& p_string) {
  
  	int begin=p_string.find("(");
  	ERR_FAIL_COND_V(begin==-1,Vector<String>());
  	begin++;
  	int end=p_string.find(")");
  	ERR_FAIL_COND_V(end<begin,Vector<String>());
  	return p_string.substr(begin,end-begin).split(",");
  }
  
  static String _get_chunk(const String& str,int &pos, int close_pos) {
  
  
  	enum {
  		MIN_COMMA,
  		MIN_COLON,
  		MIN_CLOSE,
  		MIN_QUOTE,
  		MIN_PARENTHESIS,
  		MIN_CURLY_OPEN,
  		MIN_OPEN
  	};
  
  	int min_pos=close_pos;
  	int min_what=MIN_CLOSE;
  
  #define TEST_MIN(m_how,m_what) \
  {\
  int res = str.find(m_how,pos);\
  if (res!=-1 && res < min_pos) {\
  	min_pos=res;\
  	min_what=m_what;\
  }\
  }\
  
  
  	TEST_MIN(",",MIN_COMMA);
  	TEST_MIN("[",MIN_OPEN);
  	TEST_MIN("{",MIN_CURLY_OPEN);
  	TEST_MIN("(",MIN_PARENTHESIS);
  	TEST_MIN("\"",MIN_QUOTE);
  
  	int end=min_pos;
  
  
  	switch(min_what) {
  
  		case MIN_COMMA: {
  		} break;
  		case MIN_CLOSE: {
  			//end because it's done
  		} break;
  		case MIN_QUOTE: {
  			end=str.find("\"",min_pos+1)+1;
  			ERR_FAIL_COND_V(end==-1,Variant());
  
  		} break;
  		case MIN_PARENTHESIS: {
  
  			end=str.find(")",min_pos+1)+1;
  			ERR_FAIL_COND_V(end==-1,Variant());
  
  		} break;
  		case MIN_OPEN: {
  			int level=1;
  			end++;
  			while(end<close_pos) {
  
  				if (str[end]=='[')
  					level++;
  				if (str[end]==']') {
  					level--;
  					if (level==0)
  						break;
  				}
  				end++;
  			}
  			ERR_FAIL_COND_V(level!=0,Variant());
  			end++;
  		} break;
  		case MIN_CURLY_OPEN: {
  			int level=1;
  			end++;
  			while(end<close_pos) {
  
  				if (str[end]=='{')
  					level++;
  				if (str[end]=='}') {
  					level--;
  					if (level==0)
  						break;
  				}
  				end++;
  			}
  			ERR_FAIL_COND_V(level!=0,Variant());
  			end++;
  		} break;
  
  	}
  
  	String ret = str.substr(pos,end-pos);
  
  	pos=end;
  	while(pos<close_pos) {
  		if (str[pos]!=',' && str[pos]!=' ' && str[pos]!=':')
  			break;
  		pos++;
  	}
  
  	return ret;
  
  }
  
  static Variant _decode_variant(const String& p_string) {
  
  
  	String str = p_string.strip_edges();
  
  	if (str.nocasecmp_to("true")==0)
  		return Variant(true);
  	if (str.nocasecmp_to("false")==0)
  		return Variant(false);
  	if (str.nocasecmp_to("nil")==0)
  		return Variant();
  	if (str.is_valid_float()) {
  		if (str.find(".")==-1)
  			return str.to_int();
  		else
  			return str.to_double();
  
  	}
  	if (str.begins_with("#")) { //string
  		return Color::html(str);
  	}
  	if (str.begins_with("\"")) { //string
  		int end = str.find_last("\"");
  		ERR_FAIL_COND_V(end==0,Variant());
  		return str.substr(1,end-1).xml_unescape();
  
  	}
  
  	if (str.begins_with("[")) { //array
  
  		int close_pos = str.find_last("]");
  		ERR_FAIL_COND_V(close_pos==-1,Variant());
  		Array array;
  
  		int pos=1;
  
  		while(pos<close_pos) {
  
  			String s = _get_chunk(str,pos,close_pos);
  			array.push_back(_decode_variant(s));
  		}
  		return array;
  
  	}
  
  	if (str.begins_with("{")) { //array
  
  		int close_pos = str.find_last("}");
  		ERR_FAIL_COND_V(close_pos==-1,Variant());
  		Dictionary d;
  
  		int pos=1;
  
  		while(pos<close_pos) {
  
  			String key = _get_chunk(str,pos,close_pos);
  			String data = _get_chunk(str,pos,close_pos);
  			d[_decode_variant(key)]=_decode_variant(data);
  		}
  		return d;
  
  	}
  	if (str.begins_with("key")) {
  		Vector<String> params = _decode_params(p_string);
  		ERR_FAIL_COND_V(params.size()!=1 && params.size()!=2,Variant());
  		int scode=0;
  
  		if (params[0].is_numeric()) {
  			scode=params[0].to_int();
  			if (scode<10)
  				scode+=KEY_0;
  		} else
  			scode=find_keycode(params[0]);
  
  		InputEvent ie;
  		ie.type=InputEvent::KEY;
  		ie.key.scancode=scode;
  
  		if (params.size()==2) {
  			String mods=params[1];
  			if (mods.findn("C")!=-1)
  				ie.key.mod.control=true;
  			if (mods.findn("A")!=-1)
  				ie.key.mod.alt=true;
  			if (mods.findn("S")!=-1)
  				ie.key.mod.shift=true;
  			if (mods.findn("M")!=-1)
  				ie.key.mod.meta=true;
  		}
  		return ie;
  
  	}
  
  	if (str.begins_with("mbutton")) {
  		Vector<String> params = _decode_params(p_string);
  		ERR_FAIL_COND_V(params.size()!=2,Variant());
  
  		InputEvent ie;
  		ie.type=InputEvent::MOUSE_BUTTON;
  		ie.device=params[0].to_int();
  		ie.mouse_button.button_index=params[1].to_int();
  
  		return ie;
  	}
  
  	if (str.begins_with("jbutton")) {
  		Vector<String> params = _decode_params(p_string);
  		ERR_FAIL_COND_V(params.size()!=2,Variant());
  
  		InputEvent ie;
  		ie.type=InputEvent::JOYSTICK_BUTTON;
  		ie.device=params[0].to_int();
  		ie.joy_button.button_index=params[1].to_int();
  
  		return ie;
  	}
  
  	if (str.begins_with("jaxis")) {
  		Vector<String> params = _decode_params(p_string);
  		ERR_FAIL_COND_V(params.size()!=2,Variant());
  
  		InputEvent ie;
  		ie.type=InputEvent::JOYSTICK_MOTION;
  		ie.device=params[0].to_int();
  		ie.joy_motion.axis=params[1].to_int();
  
  		return ie;
  	}
  	if (str.begins_with("img")) {
  		Vector<String> params = _decode_params(p_string);
  		if (params.size()==0) {
  			return Image();
  		}
  
  		ERR_FAIL_COND_V(params.size()!=5,Image());
  
  		String format=params[0].strip_edges();
  
  		Image::Format imgformat;
  
  		if (format=="grayscale") {
  			imgformat=Image::FORMAT_GRAYSCALE;
  		} else if (format=="intensity") {
  			imgformat=Image::FORMAT_INTENSITY;
  		} else if (format=="grayscale_alpha") {
  			imgformat=Image::FORMAT_GRAYSCALE_ALPHA;
  		} else if (format=="rgb") {
  			imgformat=Image::FORMAT_RGB;
  		} else if (format=="rgba") {
  			imgformat=Image::FORMAT_RGBA;
  		} else if (format=="indexed") {
  			imgformat=Image::FORMAT_INDEXED;
  		} else if (format=="indexed_alpha") {
  			imgformat=Image::FORMAT_INDEXED_ALPHA;
  		} else if (format=="bc1") {
  			imgformat=Image::FORMAT_BC1;
  		} else if (format=="bc2") {
  			imgformat=Image::FORMAT_BC2;
  		} else if (format=="bc3") {
  			imgformat=Image::FORMAT_BC3;
  		} else if (format=="bc4") {
  			imgformat=Image::FORMAT_BC4;
  		} else if (format=="bc5") {
  			imgformat=Image::FORMAT_BC5;
  		} else if (format=="custom") {
  			imgformat=Image::FORMAT_CUSTOM;
  		} else {
  
  			ERR_FAIL_V( Image() );
  		}
  
  		int mipmaps=params[1].to_int();
  		int w=params[2].to_int();
  		int h=params[3].to_int();
  
  		if (w == 0 && h == 0) {
  			//r_v = Image(w, h, imgformat);
  			return Image();
  		};
  
  
  		String data=params[4];
  		int datasize=data.length()/2;
  		DVector<uint8_t> pixels;
  		pixels.resize(datasize);
  		DVector<uint8_t>::Write wb = pixels.write();
  		const CharType *cptr=data.c_str();
  
  		int idx=0;
  		uint8_t byte;
  		while( idx<datasize*2) {
  
  			CharType c=*(cptr++);
  
  			ERR_FAIL_COND_V(c=='<',ERR_FILE_CORRUPT);
  
  			if ( (c>='0' && c<='9') || (c>='A' && c<='F') || (c>='a' && c<='f') ) {
  
  				if (idx&1) {
  
  					byte|=HEX2CHR(c);
  					wb[idx>>1]=byte;
  				} else {
  
  					byte=HEX2CHR(c)<<4;
  				}
  
  				idx++;
  			}
  
  		}
  
  		wb = DVector<uint8_t>::Write();
  
  		return Image(w,h,mipmaps,imgformat,pixels);
  	}
  
  	if (str.find(",")!=-1) { //vector2 or vector3
  		Vector<float> farr = str.split_floats(",",true);
  		if (farr.size()==2) {
  			return Point2(farr[0],farr[1]);
  		}
  		if (farr.size()==3) {
  			return Vector3(farr[0],farr[1],farr[2]);
  		}
  		ERR_FAIL_V(Variant());
  	}
  
  
  	return Variant();
  }
  
  
  Error Globals::_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 engine.cfb (not ECFG)");
  		ERR_FAIL_V(ERR_FILE_CORRUPT;)
  	}
  
  	uint32_t count=f->get_32();
  
  	for(int 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_persisting(key,true);
  	}
  
  	return OK;
  }
  Error Globals::_load_settings(const String p_path) {
  
  
  	Error err;
  	FileAccess *f= FileAccess::open(p_path,FileAccess::READ,&err);
  
  	if (err!=OK) {
  
  		return err;
  	}
  
  
  	String line;
  	String section;
  	String subpath;
  
  	int line_count = 0;
  
  	while(!f->eof_reached()) {
  
  		String line = f->get_line().strip_edges();
  		line_count++;
  
  		if (line=="")
  			continue;
  
  		// find comments
  
  		 {
  
  			int pos=0;
  			while (true) {
  				int ret = line.find(";",pos);
  				if (ret==-1)
  					break;
  
  				int qc=0;
  				for(int i=0;i<ret;i++) {
  
  					if (line[i]=='"')
  						qc++;
  				}
  
  				if ( !(qc&1) ) {
  					//not inside string, real comment
  					line=line.substr(0,ret);
  					break;
  
  				}
  
  				pos=ret+1;
  
  
  			}
  		}
  
  		if (line.begins_with("[")) {
  
  			int end = line.find_last("]");
  			ERR_CONTINUE(end!=line.length()-1);
  
  			String section=line.substr(1,line.length()-2);
  
  			if (section=="global" || section == "")
  				subpath="";
  			else
  				subpath=section+"/";
  
  		} else if (line.find("=")!=-1) {
  
  
  			int eqpos = line.find("=");
  			String var=line.substr(0,eqpos).strip_edges();
  			String value=line.substr(eqpos+1,line.length()).strip_edges();
  
  			Variant val = _decode_variant(value);
  
  			set(subpath+var,val);
  			set_persisting(subpath+var,true);
  			//props[subpath+var]=VariantContainer(val,last_order++,true);
  
  		} else {
  
  			if (line.length() > 0) {
  				ERR_PRINT(String("Syntax error on line "+itos(line_count)+" of file "+p_path).ascii().get_data());
  			};
  		};
  	}
  
  	memdelete(f);
  
  
  	return OK;
  }
  
  static String _encode_variant(const Variant& p_variant) {
  
  	switch(p_variant.get_type()) {
  
  		case Variant::BOOL: {
  			bool val = p_variant;
  			return (val?"true":"false");
  		} break;
  		case Variant::INT: {
  			int val = p_variant;
  			return itos(val);
  		} break;
  		case Variant::REAL: {
  			float val = p_variant;
  			return rtos(val)+(val==int(val)?".0":"");
  		} break;
  		case Variant::STRING: {
  			String val = p_variant;
  			return "\""+val.xml_escape()+"\"";
  		} break;
  		case Variant::COLOR: {
  
  			Color val = p_variant;
  			return "#"+val.to_html();
  		} break;
  		case Variant::STRING_ARRAY:
  		case Variant::INT_ARRAY:
  		case Variant::REAL_ARRAY:
  		case Variant::ARRAY: {
  			Array arr = p_variant;
  			String str="[";
  			for(int i=0;i<arr.size();i++) {
  
  				if (i>0)
  					str+=", ";
  				str+=_encode_variant(arr[i]);
  			}
  			str+="]";
  			return str;
  		} break;
  		case Variant::DICTIONARY: {
  			Dictionary d = p_variant;
  			String str="{";
  			List<Variant> keys;
  			d.get_key_list(&keys);
  			for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
  
  				if (E!=keys.front())
  					str+=", ";
  				str+=_encode_variant(E->get());
  				str+=":";
  				str+=_encode_variant(d[E->get()]);
  
  			}
  			str+="}";
  			return str;
  		} break;
  		case Variant::IMAGE: {
  			String str="img(";
  
  			Image img=p_variant;
  			if (!img.empty()) {
  
  				String format;
  				switch(img.get_format()) {
  
  					case Image::FORMAT_GRAYSCALE: format="grayscale"; break;
  					case Image::FORMAT_INTENSITY: format="intensity"; break;
  					case Image::FORMAT_GRAYSCALE_ALPHA: format="grayscale_alpha"; break;
  					case Image::FORMAT_RGB: format="rgb"; break;
  					case Image::FORMAT_RGBA: format="rgba"; break;
  					case Image::FORMAT_INDEXED : format="indexed"; break;
  					case Image::FORMAT_INDEXED_ALPHA: format="indexed_alpha"; break;
  					case Image::FORMAT_BC1: format="bc1"; break;
  					case Image::FORMAT_BC2: format="bc2"; break;
  					case Image::FORMAT_BC3: format="bc3"; break;
  					case Image::FORMAT_BC4: format="bc4"; break;
  					case Image::FORMAT_BC5: format="bc5"; break;
  					case Image::FORMAT_CUSTOM: format="custom custom_size="+itos(img.get_data().size())+""; break;
  					default: {}
  				}
  
  				str+=format+", ";
  				str+=itos(img.get_mipmaps())+", ";
  				str+=itos(img.get_width())+", ";
  				str+=itos(img.get_height())+", ";
  				DVector<uint8_t> data = img.get_data();
  				int ds=data.size();
  				DVector<uint8_t>::Read r = data.read();
  				for(int i=0;i<ds;i++) {
  					uint8_t byte = r[i];
  					const char  hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  					char bstr[3]={ hex[byte>>4], hex[byte&0xF], 0};
  					str+=bstr;
  				}
  			}
  			str+=")";
  			return str;
  		} break;
  		case Variant::INPUT_EVENT: {
  
  			InputEvent ev = p_variant;
  
  			switch(ev.type) {
  
  				case InputEvent::KEY: {
  
  					String mods;
  					if (ev.key.mod.control)
  						mods+="C";
  					if (ev.key.mod.shift)
  						mods+="S";
  					if (ev.key.mod.alt)
  						mods+="A";
  					if (ev.key.mod.meta)
  						mods+="M";
  					if (mods!="")
  						mods=", "+mods;
  
  					return "key("+keycode_get_string(ev.key.scancode)+mods+")";
  				} break;
  				case InputEvent::MOUSE_BUTTON: {
  
  					return "mbutton("+itos(ev.device)+", "+itos(ev.mouse_button.button_index)+")";
  				} break;
  				case InputEvent::JOYSTICK_BUTTON: {
  
  					return "jbutton("+itos(ev.device)+", "+itos(ev.joy_button.button_index)+")";
  				} break;
  				case InputEvent::JOYSTICK_MOTION: {
  
  					return "jaxis("+itos(ev.device)+", "+itos(ev.joy_motion.axis)+")";
  				} break;
  				default: {
  
  					return "nil";
  				} break;
  
  			}
  		} break;
  		default: {}
  	}
  
  	return "nil"; //don't know wha to do with this
  }
  
  
  int Globals::get_order(const String& p_name) const {
  
  	ERR_FAIL_COND_V(!props.has(p_name),-1);
  	return props[p_name].order;
  }
  
  
  void Globals::set_order(const String& p_name, int p_order){
  
  	ERR_FAIL_COND(!props.has(p_name));
  	props[p_name].order=p_order;
  }
  
  void Globals::clear(const String& p_name) {
  
  	ERR_FAIL_COND(!props.has(p_name));
  	props.erase(p_name);
  }
  
  Error Globals::save() {
  
  	return save_custom(get_resource_path()+"/engine.cfg");
  }
  
  Error Globals::_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 engine.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 Globals::_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 engine.cfg - "+p_file);
  		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;
  }
  
  Error Globals::_save_custom_bnd(const String &p_file) { // add other params as dictionary and array?
  
  	return save_custom(p_file);
  };
  
  Error Globals::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_CHECKABLE|PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_STORAGE;
  		if (!v->persist)
  			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 engine.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 (Globals::get_singleton()->has(p_var))
  		return Globals::get_singleton()->get(p_var);
  	Globals::get_singleton()->set(p_var,p_default);
  	return p_default;
  
  }
  
  void Globals::add_singleton(const Singleton &p_singleton) {
  
  	singletons.push_back(p_singleton);
  }
  
  Object* Globals::get_singleton_object(const String& p_name) const {
  
  	for(const List<Singleton>::Element *E=singletons.front();E;E=E->next()) {
  		if (E->get().name == p_name) {
  			return E->get().ptr;
  		};
  	};
  
  	return NULL;
  };
  
  bool Globals::has_singleton(const String& p_name) const {
  
  	return get_singleton_object(p_name) != NULL;
  };
  
  void Globals::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> Globals::get_optimizer_presets() const {
  
  	List<PropertyInfo> pi;
  	Globals::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 Globals::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;
  
  }
  
  void Globals::set_disable_platform_override(bool p_disable) {
  
  	disable_platform_override=p_disable;
  }
  
  bool Globals::is_using_datapack() const {
  
  	return using_datapack;
  }
  
  void Globals::_bind_methods() {
  
  	ObjectTypeDB::bind_method(_MD("has","name"),&Globals::has);
  	ObjectTypeDB::bind_method(_MD("set_order","name","pos"),&Globals::set_order);
  	ObjectTypeDB::bind_method(_MD("get_order","name"),&Globals::get_order);
  	ObjectTypeDB::bind_method(_MD("set_persisting","name","enable"),&Globals::set_persisting);
  	ObjectTypeDB::bind_method(_MD("is_persisting","name"),&Globals::is_persisting);
  	ObjectTypeDB::bind_method(_MD("clear","name"),&Globals::clear);
  	ObjectTypeDB::bind_method(_MD("localize_path","path"),&Globals::localize_path);
  	ObjectTypeDB::bind_method(_MD("globalize_path","path"),&Globals::globalize_path);
  	ObjectTypeDB::bind_method(_MD("save"),&Globals::save);
  	ObjectTypeDB::bind_method(_MD("has_singleton"),&Globals::has_singleton);
  	ObjectTypeDB::bind_method(_MD("get_singleton"),&Globals::get_singleton_object);
  	ObjectTypeDB::bind_method(_MD("load_resource_pack"),&Globals::_load_resource_pack);
  
  	ObjectTypeDB::bind_method(_MD("save_custom"),&Globals::_save_custom_bnd);
  
  }
  
  Globals::Globals() {
  	
  
  	singleton=this;
  	last_order=0;
  	disable_platform_override=false;
  
  
  
  	Array va;
  	InputEvent key;
  	key.type=InputEvent::KEY;
  	InputEvent joyb;
  	joyb.type=InputEvent::JOYSTICK_BUTTON;
  
  
  	set("application/name","" );
  	set("application/main_scene","");
  	custom_prop_info["application/main_scene"]=PropertyInfo(Variant::STRING,"application/main_scene",PROPERTY_HINT_FILE,"scn,res,xscn,xml");
  	set("application/disable_stdout",false);
  	set("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);
  	set("input/ui_accept",va);
  
  	va=Array();
  	key.key.scancode=KEY_SPACE;
  	va.push_back(key);
  	joyb.joy_button.button_index=JOY_BUTTON_3;
  	va.push_back(joyb);
  	set("input/ui_select",va);
  
  	va=Array();
  	key.key.scancode=KEY_ESCAPE;
  	va.push_back(key);
  	joyb.joy_button.button_index=JOY_BUTTON_1;
  	va.push_back(joyb);
  	set("input/ui_cancel",va);
  
  	va=Array();
  	key.key.scancode=KEY_TAB;
  	va.push_back(key);
  	set("input/ui_focus_next",va);
  
  	va=Array();
  	key.key.scancode=KEY_TAB;
  	key.key.mod.shift=true;
  	va.push_back(key);
  	set("input/ui_focus_prev",va);
  	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);
  	set("input/ui_left",va);
  
  	va=Array();
  	key.key.scancode=KEY_RIGHT;
  	va.push_back(key);
  	joyb.joy_button.button_index=JOY_DPAD_RIGHT;
  	va.push_back(joyb);
  	set("input/ui_right",va);
  
  	va=Array();
  	key.key.scancode=KEY_UP;
  	va.push_back(key);
  	joyb.joy_button.button_index=JOY_DPAD_UP;
  	va.push_back(joyb);
  	set("input/ui_up",va);
  
  	va=Array();
  	key.key.scancode=KEY_DOWN;
  	va.push_back(key);
  	joyb.joy_button.button_index=JOY_DPAD_DOWN;
  	va.push_back(joyb);
  	set("input/ui_down",va);
  
  
  	va=Array();
  	key.key.scancode=KEY_PAGEUP;
  	va.push_back(key);
  	set("input/ui_page_up",va);
  
  	va=Array();
  	key.key.scancode=KEY_PAGEDOWN;
  	va.push_back(key);
  	set("input/ui_page_down",va);
  
  //	set("display/orientation", "landscape");
  
  
  	custom_prop_info["display/orientation"]=PropertyInfo(Variant::STRING,"display/orientation",PROPERTY_HINT_ENUM,"landscape,portrait,reverse_landscape,reverse_portrait,sensor_landscape,sensor_portrait,sensor");
  	custom_prop_info["render/mipmap_policy"]=PropertyInfo(Variant::INT,"render/mipmap_policy",PROPERTY_HINT_ENUM,"Allow,Allow For Po2,Disallow");
  	custom_prop_info["render/thread_model"]=PropertyInfo(Variant::INT,"render/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");
  
  	using_datapack=false;
  }
  
  
  Globals::~Globals() {
  	
  	singleton=NULL;
  }
  
  
  