$estr = function() { return js.Boot.__string_rec(this,''); }
iphjs = {}
iphjs.Accounts = function(server) { if( server === $_ ) return; {
this.server = server;
this.onLogin = new iph.Event();
this.onLogout = new iph.Event();
}}
iphjs.Accounts.__name__ = ["iphjs","Accounts"];
iphjs.Accounts.prototype.accountService = function(servlet,data,cb) {
iphjs.Base.doService(iph.Locator.asString(this.server) + "/" + Type.enumConstructor(servlet) + "?callback=?",data,cb);
}
iphjs.Accounts.prototype.doLogin = function(loginForm) {
var me = this;
try {
var serialized = loginForm.serialize();
this.accountService(iph.accounts.AccountServletNames.PLOGIN,serialized,function(accInfo) {
me.login(accInfo);
});
}
catch( $e0 ) {
{
var exc = $e0;
{
haxe.Log.trace(exc,{ fileName : "Accounts.hx", lineNumber : 157, className : "iphjs.Accounts", methodName : "doLogin"});
}
}
}
}
iphjs.Accounts.prototype.doLogout = function(loginForm,logoutForm) {
var me = this;
this.accountService(iph.accounts.AccountServletNames.LOGOUT,{ SESSID : this.sessID},function(d) {
loginForm.css({ display : "inline"});
logoutForm.css({ display : "none"});
new JQuery("#login-info").html("");
me.lgdIn = false;
me.onLogout.raise(me.user);
});
}
iphjs.Accounts.prototype.emMD5 = null;
iphjs.Accounts.prototype.emailMD5 = function() {
return this.emMD5;
}
iphjs.Accounts.prototype.getAccounts = function(userID,fn) {
this.accountService(iph.accounts.AccountServletNames.ACCOUNTS,{ SESSID : this.sessID, USERID : userID},function(d) {
fn(d.PAYLOAD);
});
}
iphjs.Accounts.prototype.getCredentials = function() {
if(!this.lgdIn) {
throw "getCredentials: Not logged in";
}
return { email : this.user.email, password : this.user.password, sessID : this.sessID}
}
iphjs.Accounts.prototype.getSessID = function() {
return this.sessID;
}
iphjs.Accounts.prototype.getTrans = function(accType,fn) {
this.accountService(iph.accounts.AccountServletNames.TRANSLIST,{ SESSID : this.sessID, ACCTYPE : accType, PAGE : 0, ROWS : 10, USERID : -1},function(d) {
fn(d);
});
}
iphjs.Accounts.prototype.getUser = function() {
return this.user;
}
iphjs.Accounts.prototype.lgdIn = null;
iphjs.Accounts.prototype.loggedIn = function() {
return this.lgdIn;
}
iphjs.Accounts.prototype.login = function(accInfo) {
this.setIncoming(accInfo);
new JQuery("#frmLogin").css({ display : "none"});
new JQuery("#frmLogout").css({ display : "inline"});
new JQuery("#login-info").html(this.user.userrole + ": " + this.user.handle);
this.onLogin.raise(this.user);
}
iphjs.Accounts.prototype.nvLogin = function(email,pw,site) {
var me = this;
this.accountService(iph.accounts.AccountServletNames.PLOGIN,{ EMAIL : email, PASSWORD : pw, SITE : site},function(accInfo) {
me.setIncoming(accInfo);
me.onLogin.raise(me.user);
});
}
iphjs.Accounts.prototype.onLogin = null;
iphjs.Accounts.prototype.onLogout = null;
iphjs.Accounts.prototype.server = null;
iphjs.Accounts.prototype.sessID = null;
iphjs.Accounts.prototype.setIncoming = function(accInfo) {
this.user = accInfo.user;
haxe.Log.trace("user : " + this.user,{ fileName : "Accounts.hx", lineNumber : 44, className : "iphjs.Accounts", methodName : "setIncoming"});
this.sessID = accInfo.sessID;
if(accInfo.emailMD5 != null) {
this.emMD5 = accInfo.emailMD5;
}
this.lgdIn = true;
}
iphjs.Accounts.prototype.setupLogin = function() {
var loginForm = new JQuery("#frmLogin"), logoutForm = new JQuery("#frmLogout"), me = this;
{
loginForm.submit(function() {
me.doLogin(loginForm);
return false;
});
logoutForm.submit(function() {
me.doLogout(loginForm,logoutForm);
return false; //to prevent normal browser submit and page navigation
});
;
}
}
iphjs.Accounts.prototype.signup = function() {
var emailReg = new EReg("^[a-z].+@\\w[\\w.-]+\\.[\\w.-]*[a-z][a-z]$","i");
var form = new JQuery("#frmSignup");
{
form.submit(function(e) {
var ok = true, m = "";
if(!form.EMAIL.value) {
m = "please enter your email";
ok = false;
}
if(!form.PASSWORD.value) {
m = "please enter a password";
ok = false;
}
if(!form.HANDLE.value) {
m = "please enter a Screen Name";
ok = false;
}
if(form.PASSWORD.value != form.confirm_password.value) {
m = "Password and confirmation not the same.";
ok = false;
}
if(!emailReg.match(form.EMAIL.value)) {
m = "Not a valid email address.";
ok = false;
}
if(ok) {
accountService("SIGNUP",base.formJSON(form),function(accInfo) {
login(accInfo);
});
}
else {
alert(m);
}
return false;;
});
}
}
iphjs.Accounts.prototype.updateUser = function(userID,first,last,email,handle,role,fn) {
this.accountService(iph.accounts.AccountServletNames.UPDATEUSER,{ SESSID : this.sessID, USERID : userID, FIRST : first, LAST : last, EMAIL : email, HANDLE : handle, ROLE : role},fn);
}
iphjs.Accounts.prototype.user = null;
iphjs.Accounts.prototype.__class__ = iphjs.Accounts;
StringTools = function() { }
StringTools.__name__ = ["StringTools"];
StringTools.urlEncode = function(s) {
return encodeURIComponent(s);
}
StringTools.urlDecode = function(s) {
return decodeURIComponent(s.split("+").join(" "));
}
StringTools.htmlEscape = function(s) {
return s.split("&").join("&").split("<").join("<").split(">").join(">");
}
StringTools.htmlUnescape = function(s) {
return s.split(">").join(">").split("<").join("<").split("&").join("&");
}
StringTools.startsWith = function(s,start) {
return (s.length >= start.length && s.substr(0,start.length) == start);
}
StringTools.endsWith = function(s,end) {
var elen = end.length;
var slen = s.length;
return (slen >= elen && s.substr(slen - elen,elen) == end);
}
StringTools.isSpace = function(s,pos) {
var c = s.charCodeAt(pos);
return (c >= 9 && c <= 13) || c == 32;
}
StringTools.ltrim = function(s) {
var l = s.length;
var r = 0;
while(r < l && StringTools.isSpace(s,r)) {
r++;
}
if(r > 0) return s.substr(r,l - r);
else return s;
}
StringTools.rtrim = function(s) {
var l = s.length;
var r = 0;
while(r < l && StringTools.isSpace(s,l - r - 1)) {
r++;
}
if(r > 0) {
return s.substr(0,l - r);
}
else {
return s;
}
}
StringTools.trim = function(s) {
return StringTools.ltrim(StringTools.rtrim(s));
}
StringTools.rpad = function(s,c,l) {
var sl = s.length;
var cl = c.length;
while(sl < l) {
if(l - sl < cl) {
s += c.substr(0,l - sl);
sl = l;
}
else {
s += c;
sl += cl;
}
}
return s;
}
StringTools.lpad = function(s,c,l) {
var ns = "";
var sl = s.length;
if(sl >= l) return s;
var cl = c.length;
while(sl < l) {
if(l - sl < cl) {
ns += c.substr(0,l - sl);
sl = l;
}
else {
ns += c;
sl += cl;
}
}
return ns + s;
}
StringTools.replace = function(s,sub,by) {
return s.split(sub).join(by);
}
StringTools.hex = function(n,digits) {
var neg = false;
if(n < 0) {
neg = true;
n = -n;
}
var s = n.toString(16);
s = s.toUpperCase();
if(digits != null) while(s.length < digits) s = "0" + s;
if(neg) s = "-" + s;
return s;
}
StringTools.prototype.__class__ = StringTools;
hxjson2 = {}
hxjson2.JSONEncoder = function(value) { if( value === $_ ) return; {
this.jsonString = this.convertToString(value);
}}
hxjson2.JSONEncoder.__name__ = ["hxjson2","JSONEncoder"];
hxjson2.JSONEncoder.prototype.arrayToString = function(a) {
var s = "";
{
var _g1 = 0, _g = a.length;
while(_g1 < _g) {
var i = _g1++;
if(s.length > 0) {
s += ",";
}
s += this.convertToString(a[i]);
}
}
return "[" + s + "]";
}
hxjson2.JSONEncoder.prototype.convertToString = function(value) {
if(Std["is"](value,List) || Std["is"](value,IntHash)) value = Lambda.array(value);
if(Std["is"](value,Hash)) value = this.mapHash(value);
if(Std["is"](value,String)) {
return this.escapeString((function($this) {
var $r;
var tmp = value;
$r = (Std["is"](tmp,String)?tmp:(function($this) {
var $r;
throw "Class cast error";
return $r;
}($this)));
return $r;
}(this)));
}
else if(Std["is"](value,Float)) {
return (Math.isFinite((function($this) {
var $r;
var tmp = value;
$r = (Std["is"](tmp,Float)?tmp:(function($this) {
var $r;
throw "Class cast error";
return $r;
}($this)));
return $r;
}(this)))?value + "":"null");
}
else if(Std["is"](value,Bool)) {
return (value?"true":"false");
}
else if(Std["is"](value,Array)) {
return this.arrayToString((function($this) {
var $r;
var tmp = value;
$r = (Std["is"](tmp,Array)?tmp:(function($this) {
var $r;
throw "Class cast error";
return $r;
}($this)));
return $r;
}(this)));
}
else if(Std["is"](value,Dynamic) && value != null) {
return this.objectToString(value);
}
return "null";
}
hxjson2.JSONEncoder.prototype.escapeString = function(str) {
var s = "";
var ch;
var len = str.length;
{
var _g = 0;
while(_g < len) {
var i = _g++;
ch = str.charAt(i);
switch(ch) {
case "\"":{
s += "\\\"";
}break;
case "\\":{
s += "\\\\";
}break;
case "\n":{
s += "\\n";
}break;
case "\r":{
s += "\\r";
}break;
case "\t":{
s += "\\t";
}break;
default:{
var code = ch.charCodeAt(0);
if(ch < " " || code > 127) {
var hexCode = StringTools.hex(ch.charCodeAt(0));
var zeroPad = "";
{
var _g2 = 0, _g1 = 4 - hexCode.length;
while(_g2 < _g1) {
var j = _g2++;
zeroPad += "0";
}
}
s += "\\u" + zeroPad + hexCode;
}
else {
s += ch;
}
}break;
}
}
}
return "\"" + s + "\"";
}
hxjson2.JSONEncoder.prototype.getString = function() {
return this.jsonString;
}
hxjson2.JSONEncoder.prototype.jsonString = null;
hxjson2.JSONEncoder.prototype.mapHash = function(value) {
var ret = { }
{ var $it1 = value.keys();
while( $it1.hasNext() ) { var i = $it1.next();
ret[i] = value.get(i);
}}
return ret;
}
hxjson2.JSONEncoder.prototype.objectToString = function(o) {
var s = "";
var value;
{
var _g = 0, _g1 = Reflect.fields(o);
while(_g < _g1.length) {
var key = _g1[_g];
++_g;
value = Reflect.field(o,key);
if(!Reflect.isFunction(value)) {
if(s.length > 0) {
s += ",";
}
s += this.escapeString(key) + ":" + this.convertToString(value);
}
}
}
return "{" + s + "}";
}
hxjson2.JSONEncoder.prototype.__class__ = hxjson2.JSONEncoder;
Reflect = function() { }
Reflect.__name__ = ["Reflect"];
Reflect.hasField = function(o,field) {
if(o.hasOwnProperty != null) return o.hasOwnProperty(field);
var arr = Reflect.fields(o);
{ var $it2 = arr.iterator();
while( $it2.hasNext() ) { var t = $it2.next();
if(t == field) return true;
}}
return false;
}
Reflect.field = function(o,field) {
var v = null;
try {
v = o[field];
}
catch( $e3 ) {
{
var e = $e3;
null;
}
}
return v;
}
Reflect.setField = function(o,field,value) {
o[field] = value;
}
Reflect.callMethod = function(o,func,args) {
return func.apply(o,args);
}
Reflect.fields = function(o) {
if(o == null) return new Array();
var a = new Array();
if(o.hasOwnProperty) {
for(var i in o)
if( o.hasOwnProperty(i) )
a.push(i);
;
}
else {
var t;
try {
t = o.__proto__;
}
catch( $e4 ) {
{
var e = $e4;
{
t = null;
}
}
}
if(t != null) o.__proto__ = null;
for(var i in o)
if( i != "__proto__" )
a.push(i);
;
if(t != null) o.__proto__ = t;
}
return a;
}
Reflect.isFunction = function(f) {
return typeof(f) == "function" && f.__name__ == null;
}
Reflect.compare = function(a,b) {
return ((a == b)?0:((((a) > (b))?1:-1)));
}
Reflect.compareMethods = function(f1,f2) {
if(f1 == f2) return true;
if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) return false;
return f1.scope == f2.scope && f1.method == f2.method && f1.method != null;
}
Reflect.isObject = function(v) {
if(v == null) return false;
var t = typeof(v);
return (t == "string" || (t == "object" && !v.__enum__) || (t == "function" && v.__name__ != null));
}
Reflect.deleteField = function(o,f) {
if(!Reflect.hasField(o,f)) return false;
delete(o[f]);
return true;
}
Reflect.copy = function(o) {
var o2 = { }
{
var _g = 0, _g1 = Reflect.fields(o);
while(_g < _g1.length) {
var f = _g1[_g];
++_g;
o2[f] = Reflect.field(o,f);
}
}
return o2;
}
Reflect.makeVarArgs = function(f) {
return function() {
var a = new Array();
{
var _g1 = 0, _g = arguments.length;
while(_g1 < _g) {
var i = _g1++;
a.push(arguments[i]);
}
}
return f(a);
}
}
Reflect.prototype.__class__ = Reflect;
hxjson2.JSONTokenizer = function(s,strict) { if( s === $_ ) return; {
this.jsonString = s;
this.strict = strict;
this.loc = 0;
this.nextChar();
}}
hxjson2.JSONTokenizer.__name__ = ["hxjson2","JSONTokenizer"];
hxjson2.JSONTokenizer.prototype.ch = null;
hxjson2.JSONTokenizer.prototype.getNextToken = function() {
var token = new hxjson2.JSONToken();
this.skipIgnored();
switch(this.ch) {
case "{":{
token.type = hxjson2.JSONTokenType.LEFT_BRACE;
token.value = "{";
this.nextChar();
}break;
case "}":{
token.type = hxjson2.JSONTokenType.RIGHT_BRACE;
token.value = "}";
this.nextChar();
}break;
case "[":{
token.type = hxjson2.JSONTokenType.LEFT_BRACKET;
token.value = "[";
this.nextChar();
}break;
case "]":{
token.type = hxjson2.JSONTokenType.RIGHT_BRACKET;
token.value = "]";
this.nextChar();
}break;
case ",":{
token.type = hxjson2.JSONTokenType.COMMA;
token.value = ",";
this.nextChar();
}break;
case ":":{
token.type = hxjson2.JSONTokenType.COLON;
token.value = ":";
this.nextChar();
}break;
case "t":{
var possibleTrue = "t" + this.nextChar() + this.nextChar() + this.nextChar();
if(possibleTrue == "true") {
token.type = hxjson2.JSONTokenType.TRUE;
token.value = true;
this.nextChar();
}
else {
this.parseError("Expecting 'true' but found " + possibleTrue);
}
}break;
case "f":{
var possibleFalse = "f" + this.nextChar() + this.nextChar() + this.nextChar() + this.nextChar();
if(possibleFalse == "false") {
token.type = hxjson2.JSONTokenType.FALSE;
token.value = false;
this.nextChar();
}
else {
this.parseError("Expecting 'false' but found " + possibleFalse);
}
}break;
case "n":{
var possibleNull = "n" + this.nextChar() + this.nextChar() + this.nextChar();
if(possibleNull == "null") {
token.type = hxjson2.JSONTokenType.NULL;
token.value = null;
this.nextChar();
}
else {
this.parseError("Expecting 'null' but found " + possibleNull);
}
}break;
case "N":{
var possibleNAN = "N" + this.nextChar() + this.nextChar();
if(possibleNAN == "NAN" || possibleNAN == "NaN") {
token.type = hxjson2.JSONTokenType.NAN;
token.value = Math.NaN;
this.nextChar();
}
else {
this.parseError("Expecting 'nan' but found " + possibleNAN);
}
}break;
case "\"":{
token = this.readString();
}break;
default:{
if(this.isDigit(this.ch) || this.ch == "-") {
token = this.readNumber();
}
else if(this.ch == "") {
return null;
}
else {
this.parseError("Unexpected " + this.ch + " encountered");
}
}break;
}
return token;
}
hxjson2.JSONTokenizer.prototype.hexValToInt = function(hexVal) {
var ret = 0;
{
var _g1 = 0, _g = hexVal.length;
while(_g1 < _g) {
var i = _g1++;
ret = ret << 4;
switch(hexVal.charAt(i).toUpperCase()) {
case "1":{
ret += 1;
}break;
case "2":{
ret += 2;
}break;
case "3":{
ret += 3;
}break;
case "4":{
ret += 4;
}break;
case "5":{
ret += 5;
}break;
case "6":{
ret += 6;
}break;
case "7":{
ret += 7;
}break;
case "8":{
ret += 8;
}break;
case "9":{
ret += 9;
}break;
case "A":{
ret += 10;
}break;
case "B":{
ret += 11;
}break;
case "C":{
ret += 12;
}break;
case "D":{
ret += 13;
}break;
case "E":{
ret += 14;
}break;
case "F":{
ret += 15;
}break;
}
}
}
return ret;
}
hxjson2.JSONTokenizer.prototype.isDigit = function(ch) {
return (ch >= "0" && ch <= "9");
}
hxjson2.JSONTokenizer.prototype.isHexDigit = function(ch) {
var uc = ch.toUpperCase();
return (this.isDigit(ch) || (uc >= "A" && uc <= "F"));
}
hxjson2.JSONTokenizer.prototype.isWhiteSpace = function(ch) {
return (ch == " " || ch == "\t" || ch == "\n" || ch == "\r");
}
hxjson2.JSONTokenizer.prototype.jsonString = null;
hxjson2.JSONTokenizer.prototype.loc = null;
hxjson2.JSONTokenizer.prototype.nextChar = function() {
return this.ch = this.jsonString.charAt(this.loc++);
}
hxjson2.JSONTokenizer.prototype.obj = null;
hxjson2.JSONTokenizer.prototype.parseError = function(message) {
throw new hxjson2.JSONParseError(message,this.loc,this.jsonString);
}
hxjson2.JSONTokenizer.prototype.readNumber = function() {
var input = "";
if(this.ch == "-") {
input += "-";
this.nextChar();
}
if(!this.isDigit(this.ch)) {
this.parseError("Expecting a digit");
}
if(this.ch == "0") {
input += this.ch;
this.nextChar();
if(this.isDigit(this.ch)) {
this.parseError("A digit cannot immediately follow 0");
}
else {
if(!this.strict && this.ch == "x") {
input += this.ch;
this.nextChar();
if(this.isHexDigit(this.ch)) {
input += this.ch;
this.nextChar();
}
else {
this.parseError("Number in hex format require at least one hex digit after \"0x\"");
}
while(this.isHexDigit(this.ch)) {
input += this.ch;
this.nextChar();
}
input = Std.string(this.hexValToInt(input));
}
}
}
else {
while(this.isDigit(this.ch)) {
input += this.ch;
this.nextChar();
}
}
if(this.ch == ".") {
input += ".";
this.nextChar();
if(!this.isDigit(this.ch)) {
this.parseError("Expecting a digit");
}
while(this.isDigit(this.ch)) {
input += this.ch;
this.nextChar();
}
}
if(this.ch == "e" || this.ch == "E") {
input += "e";
this.nextChar();
if(this.ch == "+" || this.ch == "-") {
input += this.ch;
this.nextChar();
}
if(!this.isDigit(this.ch)) {
this.parseError("Scientific notation number needs exponent value");
}
while(this.isDigit(this.ch)) {
input += this.ch;
this.nextChar();
}
}
var num = Std.parseFloat(input);
if(Math.isFinite(num) && !Math.isNaN(num)) {
var token = new hxjson2.JSONToken();
token.type = hxjson2.JSONTokenType.NUMBER;
token.value = num;
return token;
}
else {
this.parseError("Number " + num + " is not valid!");
}
return null;
}
hxjson2.JSONTokenizer.prototype.readString = function() {
var string = "";
this.nextChar();
while(this.ch != "\"" && this.ch != "") {
if(this.ch == "\\") {
this.nextChar();
switch(this.ch) {
case "\"":{
string += "\"";
}break;
case "/":{
string += "/";
}break;
case "\\":{
string += "\\";
}break;
case "n":{
string += "\n";
}break;
case "r":{
string += "\r";
}break;
case "t":{
string += "\t";
}break;
case "u":{
var hexValue = "";
{
var _g = 0;
while(_g < 4) {
var i = _g++;
if(!this.isHexDigit(this.nextChar())) {
this.parseError(" Excepted a hex digit, but found: " + this.ch);
}
hexValue += this.ch;
}
}
string += String.fromCharCode(this.hexValToInt(hexValue));
}break;
default:{
string += "\\" + this.ch;
}break;
}
}
else {
string += this.ch;
}
this.nextChar();
}
if(this.ch == "") {
this.parseError("Unterminated string literal");
}
this.nextChar();
var token = new hxjson2.JSONToken();
token.type = hxjson2.JSONTokenType.STRING;
token.value = string;
return token;
}
hxjson2.JSONTokenizer.prototype.skipComments = function() {
if(this.ch == "/") {
this.nextChar();
switch(this.ch) {
case "/":{
do {
this.nextChar();
} while(this.ch != "\n" && this.ch != "");
this.nextChar();
}break;
case "*":{
this.nextChar();
while(true) {
if(this.ch == "*") {
this.nextChar();
if(this.ch == "/") {
this.nextChar();
break;
}
}
else {
this.nextChar();
}
if(this.ch == "") {
this.parseError("Multi-line comment not closed");
}
}
}break;
default:{
this.parseError("Unexpected " + this.ch + " encountered (expecting '/' or '*' )");
}break;
}
}
}
hxjson2.JSONTokenizer.prototype.skipIgnored = function() {
var originalLoc;
do {
originalLoc = this.loc;
this.skipWhite();
this.skipComments();
} while(originalLoc != this.loc);
}
hxjson2.JSONTokenizer.prototype.skipWhite = function() {
while(this.isWhiteSpace(this.ch)) {
this.nextChar();
}
}
hxjson2.JSONTokenizer.prototype.strict = null;
hxjson2.JSONTokenizer.prototype.__class__ = hxjson2.JSONTokenizer;
haxe = {}
haxe.Log = function() { }
haxe.Log.__name__ = ["haxe","Log"];
haxe.Log.trace = function(v,infos) {
js.Boot.__trace(v,infos);
}
haxe.Log.clear = function() {
js.Boot.__clear_trace();
}
haxe.Log.prototype.__class__ = haxe.Log;
StringBuf = function(p) { if( p === $_ ) return; {
this.b = new Array();
}}
StringBuf.__name__ = ["StringBuf"];
StringBuf.prototype.add = function(x) {
this.b[this.b.length] = x;
}
StringBuf.prototype.addChar = function(c) {
this.b[this.b.length] = String.fromCharCode(c);
}
StringBuf.prototype.addSub = function(s,pos,len) {
this.b[this.b.length] = s.substr(pos,len);
}
StringBuf.prototype.b = null;
StringBuf.prototype.toString = function() {
return this.b.join("");
}
StringBuf.prototype.__class__ = StringBuf;
hxjson2.JSONParseError = function(message,location,text) { if( message === $_ ) return; {
if(text == null) text = "";
if(location == null) location = 0;
if(message == null) message = "";
this.name = "JSONParseError";
this._location = location;
this._text = text;
this.message = message;
}}
hxjson2.JSONParseError.__name__ = ["hxjson2","JSONParseError"];
hxjson2.JSONParseError.prototype._location = null;
hxjson2.JSONParseError.prototype._text = null;
hxjson2.JSONParseError.prototype.getlocation = function() {
return this._location;
}
hxjson2.JSONParseError.prototype.gettext = function() {
return this._text;
}
hxjson2.JSONParseError.prototype.location = null;
hxjson2.JSONParseError.prototype.message = null;
hxjson2.JSONParseError.prototype.name = null;
hxjson2.JSONParseError.prototype.text = null;
hxjson2.JSONParseError.prototype.toString = function() {
return this.name + ": " + this.message + " at position: " + this._location + " near \"" + this._text + "\"";
}
hxjson2.JSONParseError.prototype.__class__ = hxjson2.JSONParseError;
iphjs.Base = function(p) { if( p === $_ ) return; {
if(haxe.Firebug.detect()) haxe.Firebug.redirectTraces();
else haxe.Log.trace = $closure(iphjs.Base,"nullTrace");
this.onPluginsLoaded = new iph.Event();
this.htmlMacros = { }
}}
iphjs.Base.__name__ = ["iphjs","Base"];
iphjs.Base.status = function(m) {
new JQuery("#help").html("" + m + "
").fadeIn();
}
iphjs.Base.nullTrace = function(v,inf) {
null;
}
iphjs.Base.doService = function(url,params,cb) {
var p;
if(Std["is"](params,String)) {
p = params;
}
else p = JQuery.param(params);
var u = ((p.length == 0)?url:url + "&" + p);
haxe.Log.trace("service: " + u,{ fileName : "Base.hx", lineNumber : 75, className : "iphjs.Base", methodName : "doService"});
JQuery.getJSON(u,function(data) {
if(data.ERR > 0) {
if(data.MSG != null) iphjs.Base.status(data.MSG);
}
cb(data);
});
}
iphjs.Base.msg = function(m) {
var d = new JQuery("#dialog");
d.html(m);
d.dialog("open");
}
iphjs.Base.prototype.htmlMacros = null;
iphjs.Base.prototype.initDialog = function() {
var d = new JQuery("#dialog");
d.dialog({ bgiframe : true, autoOpen : false, modal : true, buttons : { Ok : function() {
d.dialog("close");
}}});
}
iphjs.Base.prototype.loadCss = function(path) {
var jq = new JQuery("link[href*=\"" + path + "\"]");
if(jq.length == 0) {
var l = new JQuery("");
l.attr({ rel : "stylesheet"});
l.attr({ type : "text/css"});
l.attr({ href : path});
l.appendTo("head");
}
}
iphjs.Base.prototype.loader = function(scripts,finalfn) {
var me = this, s = scripts.shift();
if(s != null) {
JQuery.getScript(s,function() {
me.loader(scripts,finalfn);
});
}
else {
finalfn();
}
}
iphjs.Base.prototype.locator = function() {
var me = this, l = new iph.Locator("/locator.json");
me.meta = l.data;
var scripts = [];
{
var _g = 0, _g1 = me.meta.plugins;
while(_g < _g1.length) {
var p = _g1[_g];
++_g;
if(p == "feeds") {
scripts.push("/js/google.js");
}
if(p == "tables") {
scripts.push("/js/tables.js");
}
if(p == "chat") {
scripts.push("/js/chat.js");
}
if(p == "menu") {
me.loadCss("/js/fg.menu.css");
scripts.push("/js/fg.menu.js");
}
}
}
scripts.push("/View.js");
me.loader(scripts,function() {
me.initDialog();
haxe.Log.trace("accountServer " + l.accountServer(),{ fileName : "Base.hx", lineNumber : 149, className : "iphjs.Base", methodName : "locator"});
me.onPluginsLoaded.raise({ accountServer : l.accountServer(), plugins : me.meta.plugins});
});
}
iphjs.Base.prototype.meta = null;
iphjs.Base.prototype.onPluginsLoaded = null;
iphjs.Base.prototype.ready = function() {
var me = this;
{
var _g = 0, _g1 = Type.getClassFields(iphjs.HtmlTools);
while(_g < _g1.length) {
var f = _g1[_g];
++_g;
var fld = Reflect.field(iphjs.HtmlTools,f);
if(Reflect.isFunction(fld)) this.htmlMacros[f] = fld;
}
}
new JQuery("").ready(function() {
iphjs.plugins={}
me.locator();
});
}
iphjs.Base.prototype.template = function(tmpl,data) {
var tmpl1 = StringTools.htmlUnescape(new JQuery(tmpl).get(0).innerHTML), t = new haxe.Template(tmpl1);
return t.execute(data,this.htmlMacros);
}
iphjs.Base.prototype.trace = function(s) {
if(window.console) {
window.console.log(s);
}
else null;
}
iphjs.Base.prototype.__class__ = iphjs.Base;
Controller = function(p) { if( p === $_ ) return; {
iphjs.Base.apply(this,[]);
var me = this;
this.onTabSwitch = new iph.Event();
this.onPluginsLoaded.addHandler(function(meta) {
me.accs = new iphjs.Accounts(meta.accountServer);
me.accs.setupLogin();
me.accs.onLogin.addHandler(function(user) {
iphjs.View.onLogin.raise(user);
});
me.accs.onLogout.addHandler(function(user) {
iphjs.View.onLogout.raise(user);
});
me.onTabSwitch.addHandler(function(selected) {
switch(selected) {
case "lobby":{
null;
}break;
case "account":{
null;
}break;
}
iphjs.View.onTabSwitch.raise(selected);
});
});
}}
Controller.__name__ = ["Controller"];
Controller.__super__ = iphjs.Base;
for(var k in iphjs.Base.prototype ) Controller.prototype[k] = iphjs.Base.prototype[k];
Controller.inst = null;
Controller.main = function() {
if(Controller.inst == null) {
Controller.inst = new Controller();
Controller.inst.ready();
}
}
Controller.prototype.accs = null;
Controller.prototype.gameType = null;
Controller.prototype.onTabSwitch = null;
Controller.prototype.selectedGame = null;
Controller.prototype.__class__ = Controller;
hxjson2.JSONToken = function(type,value) { if( type === $_ ) return; {
this.type = (type == null?hxjson2.JSONTokenType.UNKNOWN:type);
this.value = value;
}}
hxjson2.JSONToken.__name__ = ["hxjson2","JSONToken"];
hxjson2.JSONToken.prototype.type = null;
hxjson2.JSONToken.prototype.value = null;
hxjson2.JSONToken.prototype.__class__ = hxjson2.JSONToken;
iph = {}
iph.Locator = function(location) { if( location === $_ ) return; {
haxe.Log.trace("location is " + location,{ fileName : "Locator.hx", lineNumber : 18, className : "iph.Locator", methodName : "new"});
this.data = hxjson2.JSON.decode(haxe.Http.requestUrl(location));
}}
iph.Locator.__name__ = ["iph","Locator"];
iph.Locator.asString = function(l) {
return "http://" + l.host + ":" + l.port;
}
iph.Locator.prototype.accountServer = function() {
return { host : this.data.accountServer.host, port : Std["int"](this.data.accountServer.port)}
}
iph.Locator.prototype.bingoServer = function() {
return { host : this.data.bingoServer.host, port : Std["int"](this.data.bingoServer.port)}
}
iph.Locator.prototype.chatServer = function() {
return { host : this.data.chatServer.host, port : Std["int"](this.data.chatServer.port)}
}
iph.Locator.prototype.data = null;
iph.Locator.prototype.site = function() {
return this.data.site;
}
iph.Locator.prototype.__class__ = iph.Locator;
haxe._Template = {}
haxe._Template.TemplateExpr = { __ename__ : ["haxe","_Template","TemplateExpr"], __constructs__ : ["OpVar","OpExpr","OpIf","OpStr","OpBlock","OpForeach","OpMacro"] }
haxe._Template.TemplateExpr.OpBlock = function(l) { var $x = ["OpBlock",4,l]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpExpr = function(expr) { var $x = ["OpExpr",1,expr]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpForeach = function(expr,loop) { var $x = ["OpForeach",5,expr,loop]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpIf = function(expr,eif,eelse) { var $x = ["OpIf",2,expr,eif,eelse]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpMacro = function(name,params) { var $x = ["OpMacro",6,name,params]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpStr = function(str) { var $x = ["OpStr",3,str]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
haxe._Template.TemplateExpr.OpVar = function(v) { var $x = ["OpVar",0,v]; $x.__enum__ = haxe._Template.TemplateExpr; $x.toString = $estr; return $x; }
EReg = function(r,opt) { if( r === $_ ) return; {
opt = opt.split("u").join("");
this.r = new RegExp(r,opt);
}}
EReg.__name__ = ["EReg"];
EReg.prototype.customReplace = function(s,f) {
var buf = new StringBuf();
while(true) {
if(!this.match(s)) break;
buf.b[buf.b.length] = this.matchedLeft();
buf.b[buf.b.length] = f(this);
s = this.matchedRight();
}
buf.b[buf.b.length] = s;
return buf.b.join("");
}
EReg.prototype.match = function(s) {
this.r.m = this.r.exec(s);
this.r.s = s;
this.r.l = RegExp.leftContext;
this.r.r = RegExp.rightContext;
return (this.r.m != null);
}
EReg.prototype.matched = function(n) {
return (this.r.m != null && n >= 0 && n < this.r.m.length?this.r.m[n]:(function($this) {
var $r;
throw "EReg::matched";
return $r;
}(this)));
}
EReg.prototype.matchedLeft = function() {
if(this.r.m == null) throw "No string matched";
if(this.r.l == null) return this.r.s.substr(0,this.r.m.index);
return this.r.l;
}
EReg.prototype.matchedPos = function() {
if(this.r.m == null) throw "No string matched";
return { pos : this.r.m.index, len : this.r.m[0].length}
}
EReg.prototype.matchedRight = function() {
if(this.r.m == null) throw "No string matched";
if(this.r.r == null) {
var sz = this.r.m.index + this.r.m[0].length;
return this.r.s.substr(sz,this.r.s.length - sz);
}
return this.r.r;
}
EReg.prototype.r = null;
EReg.prototype.replace = function(s,by) {
return s.replace(this.r,by);
}
EReg.prototype.split = function(s) {
var d = "#__delim__#";
return s.replace(this.r,d).split(d);
}
EReg.prototype.__class__ = EReg;
haxe.Template = function(str) { if( str === $_ ) return; {
var tokens = this.parseTokens(str);
this.expr = this.parseBlock(tokens);
if(!tokens.isEmpty()) throw "Unexpected '" + tokens.first().s + "'";
}}
haxe.Template.__name__ = ["haxe","Template"];
haxe.Template.prototype.buf = null;
haxe.Template.prototype.context = null;
haxe.Template.prototype.execute = function(context,macros) {
this.macros = (macros == null?{ }:macros);
this.context = context;
this.stack = new List();
this.buf = new StringBuf();
this.run(this.expr);
return this.buf.b.join("");
}
haxe.Template.prototype.expr = null;
haxe.Template.prototype.macros = null;
haxe.Template.prototype.makeConst = function(v) {
haxe.Template.expr_trim.match(v);
v = haxe.Template.expr_trim.matched(1);
if(v.charCodeAt(0) == 34) {
var str = v.substr(1,v.length - 2);
return function() {
return str;
}
}
if(haxe.Template.expr_int.match(v)) {
var i = Std.parseInt(v);
return function() {
return i;
}
}
if(haxe.Template.expr_float.match(v)) {
var f = Std.parseFloat(v);
return function() {
return f;
}
}
var me = this;
return function() {
return me.resolve(v);
}
}
haxe.Template.prototype.makeExpr = function(l) {
return this.makePath(this.makeExpr2(l),l);
}
haxe.Template.prototype.makeExpr2 = function(l) {
var p = l.pop();
if(p == null) throw "";
if(p.s) return this.makeConst(p.p);
switch(p.p) {
case "(":{
var e1 = this.makeExpr(l);
var p1 = l.pop();
if(p1 == null || p1.s) throw p1.p;
if(p1.p == ")") return e1;
var e2 = this.makeExpr(l);
var p2 = l.pop();
if(p2 == null || p2.p != ")") throw p2.p;
return (function($this) {
var $r;
switch(p1.p) {
case "+":{
$r = function() {
return e1() + e2();
}
}break;
case "-":{
$r = function() {
return e1() - e2();
}
}break;
case "*":{
$r = function() {
return e1() * e2();
}
}break;
case "/":{
$r = function() {
return e1() / e2();
}
}break;
case ">":{
$r = function() {
return e1() > e2();
}
}break;
case "<":{
$r = function() {
return e1() < e2();
}
}break;
case ">=":{
$r = function() {
return e1() >= e2();
}
}break;
case "<=":{
$r = function() {
return e1() <= e2();
}
}break;
case "==":{
$r = function() {
return e1() == e2();
}
}break;
case "!=":{
$r = function() {
return e1() != e2();
}
}break;
case "&&":{
$r = function() {
return e1() && e2();
}
}break;
case "||":{
$r = function() {
return e1() || e2();
}
}break;
default:{
$r = (function($this) {
var $r;
throw "Unknown operation " + p1.p;
return $r;
}($this));
}break;
}
return $r;
}(this));
}break;
case "!":{
var e = this.makeExpr(l);
return function() {
var v = e();
return (v == null || v == false);
}
}break;
case "-":{
var e = this.makeExpr(l);
return function() {
return -e();
}
}break;
}
throw p.p;
}
haxe.Template.prototype.makePath = function(e,l) {
var p = l.first();
if(p == null || p.p != ".") return e;
l.pop();
var field = l.pop();
if(field == null || !field.s) throw field.p;
var f = field.p;
haxe.Template.expr_trim.match(f);
f = haxe.Template.expr_trim.matched(1);
return this.makePath(function() {
return Reflect.field(e(),f);
},l);
}
haxe.Template.prototype.parse = function(tokens) {
var t = tokens.pop();
var p = t.p;
if(t.s) return haxe._Template.TemplateExpr.OpStr(p);
if(t.l != null) {
var pe = new List();
{
var _g = 0, _g1 = t.l;
while(_g < _g1.length) {
var p1 = _g1[_g];
++_g;
pe.add(this.parseBlock(this.parseTokens(p1)));
}
}
return haxe._Template.TemplateExpr.OpMacro(p,pe);
}
if(p.substr(0,3) == "if ") {
p = p.substr(3,p.length - 3);
var e = this.parseExpr(p);
var eif = this.parseBlock(tokens);
var t1 = tokens.first();
var eelse;
if(t1 == null) throw "Unclosed 'if'";
if(t1.p == "end") {
tokens.pop();
eelse = null;
}
else if(t1.p == "else") {
tokens.pop();
eelse = this.parseBlock(tokens);
t1 = tokens.pop();
if(t1 == null || t1.p != "end") throw "Unclosed 'else'";
}
else {
t1.p = t1.p.substr(4,t1.p.length - 4);
eelse = this.parse(tokens);
}
return haxe._Template.TemplateExpr.OpIf(e,eif,eelse);
}
if(p.substr(0,8) == "foreach ") {
p = p.substr(8,p.length - 8);
var e = this.parseExpr(p);
var efor = this.parseBlock(tokens);
var t1 = tokens.pop();
if(t1 == null || t1.p != "end") throw "Unclosed 'foreach'";
return haxe._Template.TemplateExpr.OpForeach(e,efor);
}
if(haxe.Template.expr_splitter.match(p)) return haxe._Template.TemplateExpr.OpExpr(this.parseExpr(p));
return haxe._Template.TemplateExpr.OpVar(p);
}
haxe.Template.prototype.parseBlock = function(tokens) {
var l = new List();
while(true) {
var t = tokens.first();
if(t == null) break;
if(!t.s && (t.p == "end" || t.p == "else" || t.p.substr(0,7) == "elseif ")) break;
l.add(this.parse(tokens));
}
if(l.length == 1) return l.first();
return haxe._Template.TemplateExpr.OpBlock(l);
}
haxe.Template.prototype.parseExpr = function(data) {
var l = new List();
var expr = data;
while(haxe.Template.expr_splitter.match(data)) {
var p = haxe.Template.expr_splitter.matchedPos();
var k = p.pos + p.len;
if(p.pos != 0) l.add({ p : data.substr(0,p.pos), s : true});
var p1 = haxe.Template.expr_splitter.matched(0);
l.add({ p : p1, s : p1.indexOf("\"") >= 0});
data = haxe.Template.expr_splitter.matchedRight();
}
if(data.length != 0) l.add({ p : data, s : true});
var e;
try {
e = this.makeExpr(l);
if(!l.isEmpty()) throw l.first().p;
}
catch( $e5 ) {
if( js.Boot.__instanceof($e5,String) ) {
var s = $e5;
{
throw "Unexpected '" + s + "' in " + expr;
}
} else throw($e5);
}
return function() {
try {
return e();
}
catch( $e6 ) {
{
var exc = $e6;
{
throw "Error : " + Std.string(exc) + " in " + expr;
}
}
}
}
}
haxe.Template.prototype.parseTokens = function(data) {
var tokens = new List();
while(haxe.Template.splitter.match(data)) {
var p = haxe.Template.splitter.matchedPos();
if(p.pos > 0) tokens.add({ p : data.substr(0,p.pos), s : true, l : null});
if(data.charCodeAt(p.pos) == 58) {
tokens.add({ p : data.substr(p.pos + 2,p.len - 4), s : false, l : null});
data = haxe.Template.splitter.matchedRight();
continue;
}
var parp = p.pos + p.len;
var npar = 1;
while(npar > 0) {
var c = data.charCodeAt(parp);
if(c == 40) npar++;
else if(c == 41) npar--;
else if(c == null) throw "Unclosed macro parenthesis";
parp++;
}
var params = data.substr(p.pos + p.len,parp - (p.pos + p.len) - 1).split(",");
tokens.add({ p : haxe.Template.splitter.matched(2), s : false, l : params});
data = data.substr(parp,data.length - parp);
}
if(data.length > 0) tokens.add({ p : data, s : true, l : null});
return tokens;
}
haxe.Template.prototype.resolve = function(v) {
if(Reflect.hasField(this.context,v)) return Reflect.field(this.context,v);
{ var $it7 = this.stack.iterator();
while( $it7.hasNext() ) { var ctx = $it7.next();
if(Reflect.hasField(ctx,v)) return Reflect.field(ctx,v);
}}
if(v == "__current__") return this.context;
return Reflect.field(haxe.Template.globals,v);
}
haxe.Template.prototype.run = function(e) {
var $e = (e);
switch( $e[1] ) {
case 0:
var v = $e[2];
{
this.buf.add(Std.string(this.resolve(v)));
}break;
case 1:
var e1 = $e[2];
{
this.buf.add(Std.string(e1()));
}break;
case 2:
var eelse = $e[4], eif = $e[3], e1 = $e[2];
{
var v = e1();
if(v == null || v == false) {
if(eelse != null) this.run(eelse);
}
else this.run(eif);
}break;
case 3:
var str = $e[2];
{
this.buf.add(str);
}break;
case 4:
var l = $e[2];
{
{ var $it8 = l.iterator();
while( $it8.hasNext() ) { var e1 = $it8.next();
this.run(e1);
}}
}break;
case 5:
var loop = $e[3], e1 = $e[2];
{
var v = e1();
try {
if(v.hasNext == null) {
var x = v.iterator();
if(x.hasNext == null) throw null;
v = x;
}
}
catch( $e9 ) {
{
var e2 = $e9;
{
throw "Cannot iter on " + v;
}
}
}
this.stack.push(this.context);
var v1 = v;
{ var $it10 = v1;
while( $it10.hasNext() ) { var ctx = $it10.next();
{
this.context = ctx;
this.run(loop);
}
}}
this.context = this.stack.pop();
}break;
case 6:
var params = $e[3], m = $e[2];
{
var v = Reflect.field(this.macros,m);
var pl = new Array();
var old = this.buf;
pl.push($closure(this,"resolve"));
{ var $it11 = params.iterator();
while( $it11.hasNext() ) { var p = $it11.next();
{
var $e = (p);
switch( $e[1] ) {
case 0:
var v1 = $e[2];
{
pl.push(this.resolve(v1));
}break;
default:{
this.buf = new StringBuf();
this.run(p);
pl.push(this.buf.b.join(""));
}break;
}
}
}}
this.buf = old;
try {
this.buf.add(Std.string(v.apply(this.macros,pl)));
}
catch( $e12 ) {
{
var e1 = $e12;
{
var plstr = (function($this) {
var $r;
try {
$r = pl.join(",");
}
catch( $e13 ) {
{
var e2 = $e13;
$r = "???";
}
}
return $r;
}(this));
var msg = "Macro call " + m + "(" + plstr + ") failed (" + Std.string(e1) + ")";
throw msg;
}
}
}
}break;
}
}
haxe.Template.prototype.stack = null;
haxe.Template.prototype.__class__ = haxe.Template;
haxe.Firebug = function() { }
haxe.Firebug.__name__ = ["haxe","Firebug"];
haxe.Firebug.detect = function() {
try {
return console != null && console.error != null;
}
catch( $e14 ) {
{
var e = $e14;
{
return false;
}
}
}
}
haxe.Firebug.redirectTraces = function() {
haxe.Log.trace = $closure(haxe.Firebug,"trace");
js.Lib.setErrorHandler($closure(haxe.Firebug,"onError"));
}
haxe.Firebug.onError = function(err,stack) {
var buf = err + "\n";
{
var _g = 0;
while(_g < stack.length) {
var s = stack[_g];
++_g;
buf += "Called from " + s + "\n";
}
}
haxe.Firebug.trace(buf,null);
return true;
}
haxe.Firebug.trace = function(v,inf) {
var type = (inf != null && inf.customParams != null?inf.customParams[0]:null);
if(type != "warn" && type != "info" && type != "debug" && type != "error") type = (inf == null?"error":"log");
console[type](((inf == null?"":inf.fileName + ":" + inf.lineNumber + " : ")) + Std.string(v));
}
haxe.Firebug.prototype.__class__ = haxe.Firebug;
IntIter = function(min,max) { if( min === $_ ) return; {
this.min = min;
this.max = max;
}}
IntIter.__name__ = ["IntIter"];
IntIter.prototype.hasNext = function() {
return this.min < this.max;
}
IntIter.prototype.max = null;
IntIter.prototype.min = null;
IntIter.prototype.next = function() {
return this.min++;
}
IntIter.prototype.__class__ = IntIter;
Std = function() { }
Std.__name__ = ["Std"];
Std["is"] = function(v,t) {
return js.Boot.__instanceof(v,t);
}
Std.string = function(s) {
return js.Boot.__string_rec(s,"");
}
Std["int"] = function(x) {
if(x < 0) return Math.ceil(x);
return Math.floor(x);
}
Std.parseInt = function(x) {
var v = parseInt(x);
if(Math.isNaN(v)) return null;
return v;
}
Std.parseFloat = function(x) {
return parseFloat(x);
}
Std.random = function(x) {
return Math.floor(Math.random() * x);
}
Std.prototype.__class__ = Std;
Lambda = function() { }
Lambda.__name__ = ["Lambda"];
Lambda.array = function(it) {
var a = new Array();
{ var $it15 = it.iterator();
while( $it15.hasNext() ) { var i = $it15.next();
a.push(i);
}}
return a;
}
Lambda.list = function(it) {
var l = new List();
{ var $it16 = it.iterator();
while( $it16.hasNext() ) { var i = $it16.next();
l.add(i);
}}
return l;
}
Lambda.map = function(it,f) {
var l = new List();
{ var $it17 = it.iterator();
while( $it17.hasNext() ) { var x = $it17.next();
l.add(f(x));
}}
return l;
}
Lambda.mapi = function(it,f) {
var l = new List();
var i = 0;
{ var $it18 = it.iterator();
while( $it18.hasNext() ) { var x = $it18.next();
l.add(f(i++,x));
}}
return l;
}
Lambda.has = function(it,elt,cmp) {
if(cmp == null) {
{ var $it19 = it.iterator();
while( $it19.hasNext() ) { var x = $it19.next();
if(x == elt) return true;
}}
}
else {
{ var $it20 = it.iterator();
while( $it20.hasNext() ) { var x = $it20.next();
if(cmp(x,elt)) return true;
}}
}
return false;
}
Lambda.exists = function(it,f) {
{ var $it21 = it.iterator();
while( $it21.hasNext() ) { var x = $it21.next();
if(f(x)) return true;
}}
return false;
}
Lambda.foreach = function(it,f) {
{ var $it22 = it.iterator();
while( $it22.hasNext() ) { var x = $it22.next();
if(!f(x)) return false;
}}
return true;
}
Lambda.iter = function(it,f) {
{ var $it23 = it.iterator();
while( $it23.hasNext() ) { var x = $it23.next();
f(x);
}}
}
Lambda.filter = function(it,f) {
var l = new List();
{ var $it24 = it.iterator();
while( $it24.hasNext() ) { var x = $it24.next();
if(f(x)) l.add(x);
}}
return l;
}
Lambda.fold = function(it,f,first) {
{ var $it25 = it.iterator();
while( $it25.hasNext() ) { var x = $it25.next();
first = f(x,first);
}}
return first;
}
Lambda.count = function(it) {
var n = 0;
{ var $it26 = it.iterator();
while( $it26.hasNext() ) { var _ = $it26.next();
++n;
}}
return n;
}
Lambda.empty = function(it) {
return !it.iterator().hasNext();
}
Lambda.prototype.__class__ = Lambda;
List = function(p) { if( p === $_ ) return; {
this.length = 0;
}}
List.__name__ = ["List"];
List.prototype.add = function(item) {
var x = [item];
if(this.h == null) this.h = x;
else this.q[1] = x;
this.q = x;
this.length++;
}
List.prototype.clear = function() {
this.h = null;
this.q = null;
this.length = 0;
}
List.prototype.filter = function(f) {
var l2 = new List();
var l = this.h;
while(l != null) {
var v = l[0];
l = l[1];
if(f(v)) l2.add(v);
}
return l2;
}
List.prototype.first = function() {
return (this.h == null?null:this.h[0]);
}
List.prototype.h = null;
List.prototype.isEmpty = function() {
return (this.h == null);
}
List.prototype.iterator = function() {
return { h : this.h, hasNext : function() {
return (this.h != null);
}, next : function() {
if(this.h == null) return null;
var x = this.h[0];
this.h = this.h[1];
return x;
}}
}
List.prototype.join = function(sep) {
var s = new StringBuf();
var first = true;
var l = this.h;
while(l != null) {
if(first) first = false;
else s.b[s.b.length] = sep;
s.b[s.b.length] = l[0];
l = l[1];
}
return s.b.join("");
}
List.prototype.last = function() {
return (this.q == null?null:this.q[0]);
}
List.prototype.length = null;
List.prototype.map = function(f) {
var b = new List();
var l = this.h;
while(l != null) {
var v = l[0];
l = l[1];
b.add(f(v));
}
return b;
}
List.prototype.pop = function() {
if(this.h == null) return null;
var x = this.h[0];
this.h = this.h[1];
if(this.h == null) this.q = null;
this.length--;
return x;
}
List.prototype.push = function(item) {
var x = [item,this.h];
this.h = x;
if(this.q == null) this.q = x;
this.length++;
}
List.prototype.q = null;
List.prototype.remove = function(v) {
var prev = null;
var l = this.h;
while(l != null) {
if(l[0] == v) {
if(prev == null) this.h = l[1];
else prev[1] = l[1];
if(this.q == l) this.q = prev;
this.length--;
return true;
}
prev = l;
l = l[1];
}
return false;
}
List.prototype.toString = function() {
var s = new StringBuf();
var first = true;
var l = this.h;
s.b[s.b.length] = "{";
while(l != null) {
if(first) first = false;
else s.b[s.b.length] = ", ";
s.b[s.b.length] = Std.string(l[0]);
l = l[1];
}
s.b[s.b.length] = "}";
return s.b.join("");
}
List.prototype.__class__ = List;
haxe.Http = function(url) { if( url === $_ ) return; {
this.url = url;
this.headers = new Hash();
this.params = new Hash();
this.async = true;
}}
haxe.Http.__name__ = ["haxe","Http"];
haxe.Http.requestUrl = function(url) {
var h = new haxe.Http(url);
h.async = false;
var r = null;
h.onData = function(d) {
r = d;
}
h.onError = function(e) {
throw e;
}
h.request(false);
return r;
}
haxe.Http.prototype.async = null;
haxe.Http.prototype.headers = null;
haxe.Http.prototype.onData = function(data) {
null;
}
haxe.Http.prototype.onError = function(msg) {
null;
}
haxe.Http.prototype.onStatus = function(status) {
null;
}
haxe.Http.prototype.params = null;
haxe.Http.prototype.postData = null;
haxe.Http.prototype.request = function(post) {
var me = this;
var r = new js.XMLHttpRequest();
var onreadystatechange = function() {
if(r.readyState != 4) return;
var s = (function($this) {
var $r;
try {
$r = r.status;
}
catch( $e27 ) {
{
var e = $e27;
$r = null;
}
}
return $r;
}(this));
if(s == undefined) s = null;
if(s != null) me.onStatus(s);
if(s != null && s >= 200 && s < 400) me.onData(r.responseText);
else switch(s) {
case null:{
me.onError("Failed to connect or resolve host");
}break;
case 12029:{
me.onError("Failed to connect to host");
}break;
case 12007:{
me.onError("Unknown host");
}break;
default:{
me.onError("Http Error #" + r.status);
}break;
}
}
r.onreadystatechange = onreadystatechange;
var uri = this.postData;
if(uri != null) post = true;
else { var $it28 = this.params.keys();
while( $it28.hasNext() ) { var p = $it28.next();
{
if(uri == null) uri = "";
else uri += "&";
uri += StringTools.urlDecode(p) + "=" + StringTools.urlEncode(this.params.get(p));
}
}}
try {
if(post) r.open("POST",this.url,this.async);
else if(uri != null) {
var question = this.url.split("?").length <= 1;
r.open("GET",this.url + ((question?"?":"&")) + uri,this.async);
uri = null;
}
else r.open("GET",this.url,this.async);
}
catch( $e29 ) {
{
var e = $e29;
{
this.onError(e.toString());
return;
}
}
}
if(this.headers.get("Content-Type") == null && post && this.postData == null) r.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
{ var $it30 = this.headers.keys();
while( $it30.hasNext() ) { var h = $it30.next();
r.setRequestHeader(h,this.headers.get(h));
}}
r.send(uri);
if(!this.async) onreadystatechange();
}
haxe.Http.prototype.setHeader = function(header,value) {
this.headers.set(header,value);
}
haxe.Http.prototype.setParameter = function(param,value) {
this.params.set(param,value);
}
haxe.Http.prototype.setPostData = function(data) {
this.postData = data;
}
haxe.Http.prototype.url = null;
haxe.Http.prototype.__class__ = haxe.Http;
iphjs.HtmlTools = function() { }
iphjs.HtmlTools.__name__ = ["iphjs","HtmlTools"];
iphjs.HtmlTools.makeSelect = function(resolve,id,fld,targets) {
var s = ["");
return s.join("");
}
iphjs.HtmlTools.prototype.__class__ = iphjs.HtmlTools;
ValueType = { __ename__ : ["ValueType"], __constructs__ : ["TNull","TInt","TFloat","TBool","TObject","TFunction","TClass","TEnum","TUnknown"] }
ValueType.TBool = ["TBool",3];
ValueType.TBool.toString = $estr;
ValueType.TBool.__enum__ = ValueType;
ValueType.TClass = function(c) { var $x = ["TClass",6,c]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
ValueType.TEnum = function(e) { var $x = ["TEnum",7,e]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
ValueType.TFloat = ["TFloat",2];
ValueType.TFloat.toString = $estr;
ValueType.TFloat.__enum__ = ValueType;
ValueType.TFunction = ["TFunction",5];
ValueType.TFunction.toString = $estr;
ValueType.TFunction.__enum__ = ValueType;
ValueType.TInt = ["TInt",1];
ValueType.TInt.toString = $estr;
ValueType.TInt.__enum__ = ValueType;
ValueType.TNull = ["TNull",0];
ValueType.TNull.toString = $estr;
ValueType.TNull.__enum__ = ValueType;
ValueType.TObject = ["TObject",4];
ValueType.TObject.toString = $estr;
ValueType.TObject.__enum__ = ValueType;
ValueType.TUnknown = ["TUnknown",8];
ValueType.TUnknown.toString = $estr;
ValueType.TUnknown.__enum__ = ValueType;
Type = function() { }
Type.__name__ = ["Type"];
Type.getClass = function(o) {
if(o == null) return null;
if(o.__enum__ != null) return null;
return o.__class__;
}
Type.getEnum = function(o) {
if(o == null) return null;
return o.__enum__;
}
Type.getSuperClass = function(c) {
return c.__super__;
}
Type.getClassName = function(c) {
if(c == null) return null;
var a = c.__name__;
return a.join(".");
}
Type.getEnumName = function(e) {
var a = e.__ename__;
return a.join(".");
}
Type.resolveClass = function(name) {
var cl;
try {
cl = eval(name);
}
catch( $e31 ) {
{
var e = $e31;
{
cl = null;
}
}
}
if(cl == null || cl.__name__ == null) return null;
return cl;
}
Type.resolveEnum = function(name) {
var e;
try {
e = eval(name);
}
catch( $e32 ) {
{
var err = $e32;
{
e = null;
}
}
}
if(e == null || e.__ename__ == null) return null;
return e;
}
Type.createInstance = function(cl,args) {
if(args.length <= 3) return new cl(args[0],args[1],args[2]);
if(args.length > 8) throw "Too many arguments";
return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
}
Type.createEmptyInstance = function(cl) {
return new cl($_);
}
Type.createEnum = function(e,constr,params) {
var f = Reflect.field(e,constr);
if(f == null) throw "No such constructor " + constr;
if(Reflect.isFunction(f)) {
if(params == null) throw "Constructor " + constr + " need parameters";
return f.apply(e,params);
}
if(params != null && params.length != 0) throw "Constructor " + constr + " does not need parameters";
return f;
}
Type.createEnumIndex = function(e,index,params) {
var c = Type.getEnumConstructs(e)[index];
if(c == null) throw index + " is not a valid enum constructor index";
return Type.createEnum(e,c,params);
}
Type.getInstanceFields = function(c) {
var a = Reflect.fields(c.prototype);
a.remove("__class__");
return a;
}
Type.getClassFields = function(c) {
var a = Reflect.fields(c);
a.remove("__name__");
a.remove("__interfaces__");
a.remove("__super__");
a.remove("prototype");
return a;
}
Type.getEnumConstructs = function(e) {
return e.__constructs__;
}
Type["typeof"] = function(v) {
switch(typeof(v)) {
case "boolean":{
return ValueType.TBool;
}break;
case "string":{
return ValueType.TClass(String);
}break;
case "number":{
if(Math.ceil(v) == v % 2147483648.0) return ValueType.TInt;
return ValueType.TFloat;
}break;
case "object":{
if(v == null) return ValueType.TNull;
var e = v.__enum__;
if(e != null) return ValueType.TEnum(e);
var c = v.__class__;
if(c != null) return ValueType.TClass(c);
return ValueType.TObject;
}break;
case "function":{
if(v.__name__ != null) return ValueType.TObject;
return ValueType.TFunction;
}break;
case "undefined":{
return ValueType.TNull;
}break;
default:{
return ValueType.TUnknown;
}break;
}
}
Type.enumEq = function(a,b) {
if(a == b) return true;
try {
if(a[0] != b[0]) return false;
{
var _g1 = 2, _g = a.length;
while(_g1 < _g) {
var i = _g1++;
if(!Type.enumEq(a[i],b[i])) return false;
}
}
var e = a.__enum__;
if(e != b.__enum__ || e == null) return false;
}
catch( $e33 ) {
{
var e = $e33;
{
return false;
}
}
}
return true;
}
Type.enumConstructor = function(e) {
return e[0];
}
Type.enumParameters = function(e) {
return e.slice(2);
}
Type.enumIndex = function(e) {
return e[1];
}
Type.prototype.__class__ = Type;
js = {}
js.Lib = function() { }
js.Lib.__name__ = ["js","Lib"];
js.Lib.isIE = null;
js.Lib.isOpera = null;
js.Lib.document = null;
js.Lib.window = null;
js.Lib.alert = function(v) {
alert(js.Boot.__string_rec(v,""));
}
js.Lib.eval = function(code) {
return eval(code);
}
js.Lib.setErrorHandler = function(f) {
js.Lib.onerror = f;
}
js.Lib.prototype.__class__ = js.Lib;
js.Boot = function() { }
js.Boot.__name__ = ["js","Boot"];
js.Boot.__unhtml = function(s) {
return s.split("&").join("&").split("<").join("<").split(">").join(">");
}
js.Boot.__trace = function(v,i) {
var msg = (i != null?i.fileName + ":" + i.lineNumber + ": ":"");
msg += js.Boot.__unhtml(js.Boot.__string_rec(v,"")) + "
";
var d = document.getElementById("haxe:trace");
if(d == null) alert("No haxe:trace element defined\n" + msg);
else d.innerHTML += msg;
}
js.Boot.__clear_trace = function() {
var d = document.getElementById("haxe:trace");
if(d != null) d.innerHTML = "";
else null;
}
js.Boot.__closure = function(o,f) {
var m = o[f];
if(m == null) return null;
var f1 = function() {
return m.apply(o,arguments);
}
f1.scope = o;
f1.method = m;
return f1;
}
js.Boot.__string_rec = function(o,s) {
if(o == null) return "null";
if(s.length >= 5) return "<...>";
var t = typeof(o);
if(t == "function" && (o.__name__ != null || o.__ename__ != null)) t = "object";
switch(t) {
case "object":{
if(o instanceof Array) {
if(o.__enum__ != null) {
if(o.length == 2) return o[0];
var str = o[0] + "(";
s += "\t";
{
var _g1 = 2, _g = o.length;
while(_g1 < _g) {
var i = _g1++;
if(i != 2) str += "," + js.Boot.__string_rec(o[i],s);
else str += js.Boot.__string_rec(o[i],s);
}
}
return str + ")";
}
var l = o.length;
var i;
var str = "[";
s += "\t";
{
var _g = 0;
while(_g < l) {
var i1 = _g++;
str += ((i1 > 0?",":"")) + js.Boot.__string_rec(o[i1],s);
}
}
str += "]";
return str;
}
var tostr;
try {
tostr = o.toString;
}
catch( $e34 ) {
{
var e = $e34;
{
return "???";
}
}
}
if(tostr != null && tostr != Object.toString) {
var s2 = o.toString();
if(s2 != "[object Object]") return s2;
}
var k = null;
var str = "{\n";
s += "\t";
var hasp = (o.hasOwnProperty != null);
for( var k in o ) { ;
if(hasp && !o.hasOwnProperty(k)) continue;
if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__") continue;
if(str.length != 2) str += ", \n";
str += s + k + " : " + js.Boot.__string_rec(o[k],s);
}
s = s.substring(1);
str += "\n" + s + "}";
return str;
}break;
case "function":{
return "";
}break;
case "string":{
return o;
}break;
default:{
return String(o);
}break;
}
}
js.Boot.__interfLoop = function(cc,cl) {
if(cc == null) return false;
if(cc == cl) return true;
var intf = cc.__interfaces__;
if(intf != null) {
var _g1 = 0, _g = intf.length;
while(_g1 < _g) {
var i = _g1++;
var i1 = intf[i];
if(i1 == cl || js.Boot.__interfLoop(i1,cl)) return true;
}
}
return js.Boot.__interfLoop(cc.__super__,cl);
}
js.Boot.__instanceof = function(o,cl) {
try {
if(o instanceof cl) {
if(cl == Array) return (o.__enum__ == null);
return true;
}
if(js.Boot.__interfLoop(o.__class__,cl)) return true;
}
catch( $e35 ) {
{
var e = $e35;
{
if(cl == null) return false;
}
}
}
switch(cl) {
case Int:{
return Math.ceil(o%2147483648.0) === o;
}break;
case Float:{
return typeof(o) == "number";
}break;
case Bool:{
return o === true || o === false;
}break;
case String:{
return typeof(o) == "string";
}break;
case Dynamic:{
return true;
}break;
default:{
if(o == null) return false;
return o.__enum__ == cl || (cl == Class && o.__name__ != null) || (cl == Enum && o.__ename__ != null);
}break;
}
}
js.Boot.__init = function() {
js.Lib.isIE = (document.all != null && window.opera == null);
js.Lib.isOpera = (window.opera != null);
Array.prototype.copy = Array.prototype.slice;
Array.prototype.insert = function(i,x) {
this.splice(i,0,x);
}
Array.prototype.remove = (Array.prototype.indexOf?function(obj) {
var idx = this.indexOf(obj);
if(idx == -1) return false;
this.splice(idx,1);
return true;
}:function(obj) {
var i = 0;
var l = this.length;
while(i < l) {
if(this[i] == obj) {
this.splice(i,1);
return true;
}
i++;
}
return false;
});
Array.prototype.iterator = function() {
return { cur : 0, arr : this, hasNext : function() {
return this.cur < this.arr.length;
}, next : function() {
return this.arr[this.cur++];
}}
}
var cca = String.prototype.charCodeAt;
String.prototype.cca = cca;
String.prototype.charCodeAt = function(i) {
var x = cca.call(this,i);
if(isNaN(x)) return null;
return x;
}
var oldsub = String.prototype.substr;
String.prototype.substr = function(pos,len) {
if(pos != null && pos != 0 && len != null && len < 0) return "";
if(len == null) len = this.length;
if(pos < 0) {
pos = this.length + pos;
if(pos < 0) pos = 0;
}
else if(len < 0) {
len = this.length + len - pos;
}
return oldsub.apply(this,[pos,len]);
}
$closure = js.Boot.__closure;
}
js.Boot.prototype.__class__ = js.Boot;
IntHash = function(p) { if( p === $_ ) return; {
this.h = {}
if(this.h.__proto__ != null) {
this.h.__proto__ = null;
delete(this.h.__proto__);
}
else null;
}}
IntHash.__name__ = ["IntHash"];
IntHash.prototype.exists = function(key) {
return this.h[key] != null;
}
IntHash.prototype.get = function(key) {
return this.h[key];
}
IntHash.prototype.h = null;
IntHash.prototype.iterator = function() {
return { ref : this.h, it : this.keys(), hasNext : function() {
return this.it.hasNext();
}, next : function() {
var i = this.it.next();
return this.ref[i];
}}
}
IntHash.prototype.keys = function() {
var a = new Array();
for( x in this.h )
a.push(x);
;
return a.iterator();
}
IntHash.prototype.remove = function(key) {
if(this.h[key] == null) return false;
delete(this.h[key]);
return true;
}
IntHash.prototype.set = function(key,value) {
this.h[key] = value;
}
IntHash.prototype.toString = function() {
var s = new StringBuf();
s.b[s.b.length] = "{";
var it = this.keys();
{ var $it36 = it;
while( $it36.hasNext() ) { var i = $it36.next();
{
s.b[s.b.length] = i;
s.b[s.b.length] = " => ";
s.b[s.b.length] = Std.string(this.get(i));
if(it.hasNext()) s.b[s.b.length] = ", ";
}
}}
s.b[s.b.length] = "}";
return s.b.join("");
}
IntHash.prototype.__class__ = IntHash;
iph.accounts = {}
iph.accounts.Params = { __ename__ : ["iph","accounts","Params"], __constructs__ : ["EMAIL","SESSID","FIRST","LAST","USERID","ACCID","HANDLE","PASSWORD","ROLE","SITE","ACCTYPE","TRNTYPE","DETAILS","VALUE","FLD","PARAM","PAGE","ROWS","ENTRY","SEVERITY","CATEGORY","TRNS","PAYLOAD","CUSTOM"] }
iph.accounts.Params.ACCID = ["ACCID",5];
iph.accounts.Params.ACCID.toString = $estr;
iph.accounts.Params.ACCID.__enum__ = iph.accounts.Params;
iph.accounts.Params.ACCTYPE = ["ACCTYPE",10];
iph.accounts.Params.ACCTYPE.toString = $estr;
iph.accounts.Params.ACCTYPE.__enum__ = iph.accounts.Params;
iph.accounts.Params.CATEGORY = ["CATEGORY",20];
iph.accounts.Params.CATEGORY.toString = $estr;
iph.accounts.Params.CATEGORY.__enum__ = iph.accounts.Params;
iph.accounts.Params.CUSTOM = ["CUSTOM",23];
iph.accounts.Params.CUSTOM.toString = $estr;
iph.accounts.Params.CUSTOM.__enum__ = iph.accounts.Params;
iph.accounts.Params.DETAILS = ["DETAILS",12];
iph.accounts.Params.DETAILS.toString = $estr;
iph.accounts.Params.DETAILS.__enum__ = iph.accounts.Params;
iph.accounts.Params.EMAIL = ["EMAIL",0];
iph.accounts.Params.EMAIL.toString = $estr;
iph.accounts.Params.EMAIL.__enum__ = iph.accounts.Params;
iph.accounts.Params.ENTRY = ["ENTRY",18];
iph.accounts.Params.ENTRY.toString = $estr;
iph.accounts.Params.ENTRY.__enum__ = iph.accounts.Params;
iph.accounts.Params.FIRST = ["FIRST",2];
iph.accounts.Params.FIRST.toString = $estr;
iph.accounts.Params.FIRST.__enum__ = iph.accounts.Params;
iph.accounts.Params.FLD = ["FLD",14];
iph.accounts.Params.FLD.toString = $estr;
iph.accounts.Params.FLD.__enum__ = iph.accounts.Params;
iph.accounts.Params.HANDLE = ["HANDLE",6];
iph.accounts.Params.HANDLE.toString = $estr;
iph.accounts.Params.HANDLE.__enum__ = iph.accounts.Params;
iph.accounts.Params.LAST = ["LAST",3];
iph.accounts.Params.LAST.toString = $estr;
iph.accounts.Params.LAST.__enum__ = iph.accounts.Params;
iph.accounts.Params.PAGE = ["PAGE",16];
iph.accounts.Params.PAGE.toString = $estr;
iph.accounts.Params.PAGE.__enum__ = iph.accounts.Params;
iph.accounts.Params.PARAM = ["PARAM",15];
iph.accounts.Params.PARAM.toString = $estr;
iph.accounts.Params.PARAM.__enum__ = iph.accounts.Params;
iph.accounts.Params.PASSWORD = ["PASSWORD",7];
iph.accounts.Params.PASSWORD.toString = $estr;
iph.accounts.Params.PASSWORD.__enum__ = iph.accounts.Params;
iph.accounts.Params.PAYLOAD = ["PAYLOAD",22];
iph.accounts.Params.PAYLOAD.toString = $estr;
iph.accounts.Params.PAYLOAD.__enum__ = iph.accounts.Params;
iph.accounts.Params.ROLE = ["ROLE",8];
iph.accounts.Params.ROLE.toString = $estr;
iph.accounts.Params.ROLE.__enum__ = iph.accounts.Params;
iph.accounts.Params.ROWS = ["ROWS",17];
iph.accounts.Params.ROWS.toString = $estr;
iph.accounts.Params.ROWS.__enum__ = iph.accounts.Params;
iph.accounts.Params.SESSID = ["SESSID",1];
iph.accounts.Params.SESSID.toString = $estr;
iph.accounts.Params.SESSID.__enum__ = iph.accounts.Params;
iph.accounts.Params.SEVERITY = ["SEVERITY",19];
iph.accounts.Params.SEVERITY.toString = $estr;
iph.accounts.Params.SEVERITY.__enum__ = iph.accounts.Params;
iph.accounts.Params.SITE = ["SITE",9];
iph.accounts.Params.SITE.toString = $estr;
iph.accounts.Params.SITE.__enum__ = iph.accounts.Params;
iph.accounts.Params.TRNS = ["TRNS",21];
iph.accounts.Params.TRNS.toString = $estr;
iph.accounts.Params.TRNS.__enum__ = iph.accounts.Params;
iph.accounts.Params.TRNTYPE = ["TRNTYPE",11];
iph.accounts.Params.TRNTYPE.toString = $estr;
iph.accounts.Params.TRNTYPE.__enum__ = iph.accounts.Params;
iph.accounts.Params.USERID = ["USERID",4];
iph.accounts.Params.USERID.toString = $estr;
iph.accounts.Params.USERID.__enum__ = iph.accounts.Params;
iph.accounts.Params.VALUE = ["VALUE",13];
iph.accounts.Params.VALUE.toString = $estr;
iph.accounts.Params.VALUE.__enum__ = iph.accounts.Params;
iph.accounts.AccountServletNames = { __ename__ : ["iph","accounts","AccountServletNames"], __constructs__ : ["PLOGIN","SLOGIN","LOGOUT","SIGNUP","TRANSACT","TRANSLIST","MULTITRANSACT","GETUSERS","FINDUSER","UPDATEUSER","MAILUSER","GETIPS","LOG","TEST","ACCOUNTS","CREATEACCOUNT","BALANCES"] }
iph.accounts.AccountServletNames.ACCOUNTS = ["ACCOUNTS",14];
iph.accounts.AccountServletNames.ACCOUNTS.toString = $estr;
iph.accounts.AccountServletNames.ACCOUNTS.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.BALANCES = ["BALANCES",16];
iph.accounts.AccountServletNames.BALANCES.toString = $estr;
iph.accounts.AccountServletNames.BALANCES.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.CREATEACCOUNT = ["CREATEACCOUNT",15];
iph.accounts.AccountServletNames.CREATEACCOUNT.toString = $estr;
iph.accounts.AccountServletNames.CREATEACCOUNT.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.FINDUSER = ["FINDUSER",8];
iph.accounts.AccountServletNames.FINDUSER.toString = $estr;
iph.accounts.AccountServletNames.FINDUSER.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.GETIPS = ["GETIPS",11];
iph.accounts.AccountServletNames.GETIPS.toString = $estr;
iph.accounts.AccountServletNames.GETIPS.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.GETUSERS = ["GETUSERS",7];
iph.accounts.AccountServletNames.GETUSERS.toString = $estr;
iph.accounts.AccountServletNames.GETUSERS.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.LOG = ["LOG",12];
iph.accounts.AccountServletNames.LOG.toString = $estr;
iph.accounts.AccountServletNames.LOG.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.LOGOUT = ["LOGOUT",2];
iph.accounts.AccountServletNames.LOGOUT.toString = $estr;
iph.accounts.AccountServletNames.LOGOUT.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.MAILUSER = ["MAILUSER",10];
iph.accounts.AccountServletNames.MAILUSER.toString = $estr;
iph.accounts.AccountServletNames.MAILUSER.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.MULTITRANSACT = ["MULTITRANSACT",6];
iph.accounts.AccountServletNames.MULTITRANSACT.toString = $estr;
iph.accounts.AccountServletNames.MULTITRANSACT.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.PLOGIN = ["PLOGIN",0];
iph.accounts.AccountServletNames.PLOGIN.toString = $estr;
iph.accounts.AccountServletNames.PLOGIN.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.SIGNUP = ["SIGNUP",3];
iph.accounts.AccountServletNames.SIGNUP.toString = $estr;
iph.accounts.AccountServletNames.SIGNUP.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.SLOGIN = ["SLOGIN",1];
iph.accounts.AccountServletNames.SLOGIN.toString = $estr;
iph.accounts.AccountServletNames.SLOGIN.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.TEST = ["TEST",13];
iph.accounts.AccountServletNames.TEST.toString = $estr;
iph.accounts.AccountServletNames.TEST.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.TRANSACT = ["TRANSACT",4];
iph.accounts.AccountServletNames.TRANSACT.toString = $estr;
iph.accounts.AccountServletNames.TRANSACT.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.TRANSLIST = ["TRANSLIST",5];
iph.accounts.AccountServletNames.TRANSLIST.toString = $estr;
iph.accounts.AccountServletNames.TRANSLIST.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.AccountServletNames.UPDATEUSER = ["UPDATEUSER",9];
iph.accounts.AccountServletNames.UPDATEUSER.toString = $estr;
iph.accounts.AccountServletNames.UPDATEUSER.__enum__ = iph.accounts.AccountServletNames;
iph.accounts.TrnClass = { __ename__ : ["iph","accounts","TrnClass"], __constructs__ : ["DEBIT","CREDIT"] }
iph.accounts.TrnClass.CREDIT = ["CREDIT",1];
iph.accounts.TrnClass.CREDIT.toString = $estr;
iph.accounts.TrnClass.CREDIT.__enum__ = iph.accounts.TrnClass;
iph.accounts.TrnClass.DEBIT = ["DEBIT",0];
iph.accounts.TrnClass.DEBIT.toString = $estr;
iph.accounts.TrnClass.DEBIT.__enum__ = iph.accounts.TrnClass;
iph.accounts.Transactions = { __ename__ : ["iph","accounts","Transactions"], __constructs__ : ["CARD","INITIAL","BINGOWIN","JACKPOT_IN","JACKPOT_OUT","DEPOSIT"] }
iph.accounts.Transactions.BINGOWIN = function(cc) { var $x = ["BINGOWIN",2,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.Transactions.CARD = function(cc) { var $x = ["CARD",0,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.Transactions.DEPOSIT = function(cc) { var $x = ["DEPOSIT",5,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.Transactions.INITIAL = function(cc) { var $x = ["INITIAL",1,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.Transactions.JACKPOT_IN = function(cc) { var $x = ["JACKPOT_IN",3,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.Transactions.JACKPOT_OUT = function(cc) { var $x = ["JACKPOT_OUT",4,cc]; $x.__enum__ = iph.accounts.Transactions; $x.toString = $estr; return $x; }
iph.accounts.AccountStatus = { __ename__ : ["iph","accounts","AccountStatus"], __constructs__ : ["OK"] }
iph.accounts.AccountStatus.OK = ["OK",0];
iph.accounts.AccountStatus.OK.toString = $estr;
iph.accounts.AccountStatus.OK.__enum__ = iph.accounts.AccountStatus;
iph.Event = function(p) { if( p === $_ ) return; {
this.handlers = [];
}}
iph.Event.__name__ = ["iph","Event"];
iph.Event.prototype.addHandler = function(fn) {
this.handlers.push(fn);
}
iph.Event.prototype.handlers = null;
iph.Event.prototype.raise = function(p) {
var _g = 0, _g1 = this.handlers;
while(_g < _g1.length) {
var h = _g1[_g];
++_g;
try {
h(p);
}
catch( $e37 ) {
{
var e = $e37;
{
haxe.Log.trace("error raising event " + e,{ fileName : "Event.hx", lineNumber : 28, className : "iph.Event", methodName : "raise"});
}
}
}
}
}
iph.Event.prototype.__class__ = iph.Event;
iph.Event0 = function(p) { if( p === $_ ) return; {
this.handlers = [];
}}
iph.Event0.__name__ = ["iph","Event0"];
iph.Event0.prototype.addHandler = function(fn) {
this.handlers.push(fn);
}
iph.Event0.prototype.handlers = null;
iph.Event0.prototype.raise = function() {
var _g = 0, _g1 = this.handlers;
while(_g < _g1.length) {
var h = _g1[_g];
++_g;
try {
h();
}
catch( $e38 ) {
{
var e = $e38;
{
haxe.Log.trace("error raising event " + e,{ fileName : "Event.hx", lineNumber : 50, className : "iph.Event0", methodName : "raise"});
}
}
}
}
}
iph.Event0.prototype.__class__ = iph.Event0;
hxjson2.JSONTokenType = { __ename__ : ["hxjson2","JSONTokenType"], __constructs__ : ["UNKNOWN","COMMA","LEFT_BRACE","RIGHT_BRACE","LEFT_BRACKET","RIGHT_BRACKET","COLON","TRUE","FALSE","NULL","STRING","NUMBER","NAN"] }
hxjson2.JSONTokenType.COLON = ["COLON",6];
hxjson2.JSONTokenType.COLON.toString = $estr;
hxjson2.JSONTokenType.COLON.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.COMMA = ["COMMA",1];
hxjson2.JSONTokenType.COMMA.toString = $estr;
hxjson2.JSONTokenType.COMMA.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.FALSE = ["FALSE",8];
hxjson2.JSONTokenType.FALSE.toString = $estr;
hxjson2.JSONTokenType.FALSE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.LEFT_BRACE = ["LEFT_BRACE",2];
hxjson2.JSONTokenType.LEFT_BRACE.toString = $estr;
hxjson2.JSONTokenType.LEFT_BRACE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.LEFT_BRACKET = ["LEFT_BRACKET",4];
hxjson2.JSONTokenType.LEFT_BRACKET.toString = $estr;
hxjson2.JSONTokenType.LEFT_BRACKET.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NAN = ["NAN",12];
hxjson2.JSONTokenType.NAN.toString = $estr;
hxjson2.JSONTokenType.NAN.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NULL = ["NULL",9];
hxjson2.JSONTokenType.NULL.toString = $estr;
hxjson2.JSONTokenType.NULL.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NUMBER = ["NUMBER",11];
hxjson2.JSONTokenType.NUMBER.toString = $estr;
hxjson2.JSONTokenType.NUMBER.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.RIGHT_BRACE = ["RIGHT_BRACE",3];
hxjson2.JSONTokenType.RIGHT_BRACE.toString = $estr;
hxjson2.JSONTokenType.RIGHT_BRACE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.RIGHT_BRACKET = ["RIGHT_BRACKET",5];
hxjson2.JSONTokenType.RIGHT_BRACKET.toString = $estr;
hxjson2.JSONTokenType.RIGHT_BRACKET.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.STRING = ["STRING",10];
hxjson2.JSONTokenType.STRING.toString = $estr;
hxjson2.JSONTokenType.STRING.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.TRUE = ["TRUE",7];
hxjson2.JSONTokenType.TRUE.toString = $estr;
hxjson2.JSONTokenType.TRUE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.UNKNOWN = ["UNKNOWN",0];
hxjson2.JSONTokenType.UNKNOWN.toString = $estr;
hxjson2.JSONTokenType.UNKNOWN.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONDecoder = function(s,strict) { if( s === $_ ) return; {
this.strict = strict;
this.tokenizer = new hxjson2.JSONTokenizer(s,strict);
this.nextToken();
this.value = this.parseValue();
if(strict && this.nextToken() != null) this.tokenizer.parseError("Unexpected characters left in input stream!");
}}
hxjson2.JSONDecoder.__name__ = ["hxjson2","JSONDecoder"];
hxjson2.JSONDecoder.prototype.getValue = function() {
return this.value;
}
hxjson2.JSONDecoder.prototype.nextToken = function() {
return this.token = this.tokenizer.getNextToken();
}
hxjson2.JSONDecoder.prototype.parseArray = function() {
var a = new Array();
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
return a;
}
else {
if(!this.strict && this.token.type == hxjson2.JSONTokenType.COMMA) {
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
return a;
}
else {
this.tokenizer.parseError("Leading commas are not supported. Expecting ']' but found " + this.token.value);
}
}
}
while(true) {
a.push(this.parseValue());
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
return a;
}
else if(this.token.type == hxjson2.JSONTokenType.COMMA) {
this.nextToken();
if(!this.strict) {
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
return a;
}
}
}
else {
this.tokenizer.parseError("Expecting ] or , but found " + this.token.value);
}
}
return null;
}
hxjson2.JSONDecoder.prototype.parseObject = function() {
var o = { }
var key;
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
return o;
}
else {
if(!this.strict && this.token.type == hxjson2.JSONTokenType.COMMA) {
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
return o;
}
else {
this.tokenizer.parseError("Leading commas are not supported. Expecting '}' but found " + this.token.value);
}
}
}
while(true) {
if(this.token.type == hxjson2.JSONTokenType.STRING) {
key = Std.string(this.token.value);
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.COLON) {
this.nextToken();
o[key] = this.parseValue();
this.nextToken();
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
return o;
}
else if(this.token.type == hxjson2.JSONTokenType.COMMA) {
this.nextToken();
if(!this.strict) {
if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
return o;
}
}
}
else {
this.tokenizer.parseError("Expecting } or , but found " + this.token.value);
}
}
else {
this.tokenizer.parseError("Expecting : but found " + this.token.value);
}
}
else {
this.tokenizer.parseError("Expecting string but found " + this.token.value);
}
}
return null;
}
hxjson2.JSONDecoder.prototype.parseValue = function() {
if(this.token == null) this.tokenizer.parseError("Unexpected end of input");
var $e = (this.token.type);
switch( $e[1] ) {
case 2:
{
return this.parseObject();
}break;
case 4:
{
return this.parseArray();
}break;
case 10:
{
return this.token.value;
}break;
case 11:
{
return this.token.value;
}break;
case 7:
{
return true;
}break;
case 8:
{
return false;
}break;
case 9:
{
return null;
}break;
case 12:
{
if(!this.strict) return this.token.value;
else this.tokenizer.parseError("Unexpected " + this.token.value);
}break;
default:{
this.tokenizer.parseError("Unexpected " + this.token.value);
}break;
}
return null;
}
hxjson2.JSONDecoder.prototype.strict = null;
hxjson2.JSONDecoder.prototype.token = null;
hxjson2.JSONDecoder.prototype.tokenizer = null;
hxjson2.JSONDecoder.prototype.value = null;
hxjson2.JSONDecoder.prototype.__class__ = hxjson2.JSONDecoder;
Hash = function(p) { if( p === $_ ) return; {
this.h = {}
if(this.h.__proto__ != null) {
this.h.__proto__ = null;
delete(this.h.__proto__);
}
else null;
}}
Hash.__name__ = ["Hash"];
Hash.prototype.exists = function(key) {
try {
key = "$" + key;
return this.hasOwnProperty.call(this.h,key);
}
catch( $e39 ) {
{
var e = $e39;
{
for(var i in this.h)
if( i == key ) return true;
;
return false;
}
}
}
}
Hash.prototype.get = function(key) {
return this.h["$" + key];
}
Hash.prototype.h = null;
Hash.prototype.iterator = function() {
return { ref : this.h, it : this.keys(), hasNext : function() {
return this.it.hasNext();
}, next : function() {
var i = this.it.next();
return this.ref["$" + i];
}}
}
Hash.prototype.keys = function() {
var a = new Array();
for(var i in this.h)
a.push(i.substr(1));
;
return a.iterator();
}
Hash.prototype.remove = function(key) {
if(!this.exists(key)) return false;
delete(this.h["$" + key]);
return true;
}
Hash.prototype.set = function(key,value) {
this.h["$" + key] = value;
}
Hash.prototype.toString = function() {
var s = new StringBuf();
s.b[s.b.length] = "{";
var it = this.keys();
{ var $it40 = it;
while( $it40.hasNext() ) { var i = $it40.next();
{
s.b[s.b.length] = i;
s.b[s.b.length] = " => ";
s.b[s.b.length] = Std.string(this.get(i));
if(it.hasNext()) s.b[s.b.length] = ", ";
}
}}
s.b[s.b.length] = "}";
return s.b.join("");
}
Hash.prototype.__class__ = Hash;
hxjson2.JSON = function() { }
hxjson2.JSON.__name__ = ["hxjson2","JSON"];
hxjson2.JSON.encode = function(o) {
return new hxjson2.JSONEncoder(o).getString();
}
hxjson2.JSON.decode = function(s,strict) {
if(strict == null) strict = true;
return new hxjson2.JSONDecoder(s,strict).getValue();
}
hxjson2.JSON.prototype.__class__ = hxjson2.JSON;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
js.Boot.__init();
{
var JQuery = window.jQuery;;
}
{
String.prototype.__class__ = String;
String.__name__ = ["String"];
Array.prototype.__class__ = Array;
Array.__name__ = ["Array"];
Int = { __name__ : ["Int"]}
Dynamic = { __name__ : ["Dynamic"]}
Float = Number;
Float.__name__ = ["Float"];
Bool = { __ename__ : ["Bool"]}
Class = { __name__ : ["Class"]}
Enum = { }
Void = { __ename__ : ["Void"]}
}
{
Math.NaN = Number["NaN"];
Math.NEGATIVE_INFINITY = Number["NEGATIVE_INFINITY"];
Math.POSITIVE_INFINITY = Number["POSITIVE_INFINITY"];
Math.isFinite = function(i) {
return isFinite(i);
}
Math.isNaN = function(i) {
return isNaN(i);
}
Math.__name__ = ["Math"];
}
{
js.Lib.document = document;
js.Lib.window = window;
onerror = function(msg,url,line) {
var f = js.Lib.onerror;
if( f == null )
return false;
return f(msg,[url+":"+line]);
}
}
{
js["XMLHttpRequest"] = (window.XMLHttpRequest?XMLHttpRequest:(window.ActiveXObject?function() {
try {
return new ActiveXObject("Msxml2.XMLHTTP");
}
catch( $e41 ) {
{
var e = $e41;
{
try {
return new ActiveXObject("Microsoft.XMLHTTP");
}
catch( $e42 ) {
{
var e1 = $e42;
{
throw "Unable to create XMLHttpRequest object.";
}
}
}
}
}
}
}:(function($this) {
var $r;
throw "Unable to create XMLHttpRequest object.";
return $r;
}(this))));
}
haxe.Template.splitter = new EReg("(::[A-Za-z0-9_ ()&|!+=/><*.\"-]+::|\\$\\$([A-Za-z0-9_-]+)\\()","");
haxe.Template.expr_splitter = new EReg("(\\(|\\)|[ \\r\\n\\t]*\"[^\"]*\"[ \\r\\n\\t]*|[!+=/><*.&|-]+)","");
haxe.Template.expr_trim = new EReg("^[ ]*([^ ]+)[ ]*$","");
haxe.Template.expr_int = new EReg("^[0-9]+$","");
haxe.Template.expr_float = new EReg("^([+-]?)(?=\\d|,\\d)\\d*(,\\d*)?([Ee]([+-]?\\d+))?$","");
haxe.Template.globals = { }
js.Lib.onerror = null;
$Main.init = Controller.main();