//-------------------------------------------------------------------------------------------------
// zvents-mini.js
// Copyright 2007 Zvents, Inc. and other authors as noted
// $Revision: 23149 $ - $Date: 2007-11-02 09:59:11 -0700 (Fri, 02 Nov 2007) $
//-------------------------------------------------------------------------------------------------

ZventsMini = {
	widget: {}
};

//-------------------------------------------------------------------------------------------------
// Rename ZventsMini as Z for convenience - most of the rest of this file is inside this function
//-------------------------------------------------------------------------------------------------

(function( Z ) {

//-------------------------------------------------------------------------------------------------
// Browser detection
//-------------------------------------------------------------------------------------------------

(function() {
	var ua = navigator.userAgent.toLowerCase();
	var opera = ver('opera'),
		msie = ! opera && ver('msie'),
		webkit = ver('webkit'),
		mozilla = ! /(compatible|webkit)/.test(ua) && ver('mozilla');
		
	Z.browser = {
		msie: msie,
		opera: opera,
		webkit: webkit,
		mozilla: mozilla,
		iePngHack: msie >= 5.5 && msie < 7.0
	};
	
	function ver( name ) {
		var i = ua.indexOf( name );
		if( i < 0 ) return false;
		i += name.length + 1;
		var dots = 0;
		for( var j = i;  use(ua.charAt(j));  j++ ) {}
		return 0 + ua.substring( i, j );
		
		function use( c ) {
			return c == '.' ? dots++ == 0 : c >= '0' && c <= '9';
		}
	}
})();

//-------------------------------------------------------------------------------------------------
// Utility functions
//-------------------------------------------------------------------------------------------------

Z.Number = {
	randomString: function( length, base ) {
		return Math.floor( Math.random() * Math.pow(base,length) ).toString( base );
	}
};

//-------------------------------------------------------------------------------------------------

Z.Object = {
	combine: function() {
		return Z.Object.updateFromArray( {}, arguments, 0 );
	},
	
	copy: function( self ) {
		return Z.Object.combine( self )
	},
	
	update: function( self ) {
		return Z.Object.updateFromArray( self, arguments, 1 );
	},
	
	updateFromArray: function( self, array, start, stop ) {
		stop = stop || array.length;
		for( var i = start;  i < stop;  i++ ) {
			var obj = array[i];
			if( obj ) for( var prop in obj ) {
				if( typeof Object.prototype[prop] == 'undefined' ) {
					var a = self[prop], b = obj[prop];
					if( typeof a == 'object'  &&  typeof b == 'object' )
						Z.Object.update( a, b );
					else
						self[prop] = b;
				}
			}
		}
		return self;
	}
};

//-------------------------------------------------------------------------------------------------

Z.Array = {
	//sort: function( input, key, numeric ) {
	//	var sep = unescape('%uFFFF');
	//	
	//	var i = 0, n = input.length, sorted = [];
	//	if( numeric ) {
	//		if( typeof key == 'function' ) {
	//			for( ;  i < n;  ++i )
	//				sorted[i] = [ ( 1000000000000000 + key(input[i]) + '' ).slice(-15), i ].join(sep);
	//		}
	//		else {
	//			for( ;  i < n;  ++i )
	//				sorted[i] = [ ( 1000000000000000 + input[i][key] + '' ).slice(-15), i ].join(sep);
	//		}
	//	}
	//	else {
	//		if( typeof key == 'function' ) {
	//			for( ;  i < n;  ++i )
	//				sorted[i] = [ key(input[i]), i ].join(sep);
	//		}
	//		else {
	//			for( ;  i < n;  ++i )
	//				sorted[i] = [ input[i][key], i ].join(sep);
	//		}
	//	}
	//	
	//	sorted.sort();
	//	
	//	var output = [];
	//	for( i = 0;  i < n;  ++i )
	//		output[i] = input[ sorted[i].split(sep)[1] ];
	//	
	//	return output;
	//}
	
	sort: function( input, key ) {
		var sep = unescape('%uFFFF');
		
		var i = 0, n = input.length, sorted = [];
		// Numeric only, non-function
		for( ;  i < n;  ++i )
			sorted[i] = [ ( 1000000000000000 + input[i][key] + '' ).slice(-15), i ].join(sep);
		
		sorted.sort();
		
		var output = [];
		for( i = 0;  i < n;  ++i )
			output[i] = input[ sorted[i].split(sep)[1] ];
		
		return output;
	}
};

//-------------------------------------------------------------------------------------------------

Z.extend = function( base, args1 ) {
	return function( args2 ) {
		return Z.call( base, args1, args2 );
	}
};

//-------------------------------------------------------------------------------------------------

Z.call = function( fn ) {
	return fn( Z.Object.updateFromArray( {}, arguments, 1 ) );
};

//-------------------------------------------------------------------------------------------------

//Z.Function = function( f, o ) {
//	return Zvents.Object.update( f, o );
//};

//-------------------------------------------------------------------------------------------------

Z.String = {
	trim: function( s ) {
		var m = s.match(/^\s*(.*)\s*$/);
		return m ? m[1] : '';
	},
	
	truncate: function( s, n ) {
		if( typeof s != 'string' ) return '';
		var len = s.length;
		if( typeof n == 'number'  &&  n < len ) {
			s = s.substring( 0, n + 1 ).replace( / +[^ ]+$/, '' ).replace( /[ ;,.]*$/, '&#8230;' );
		}
		return s;
	}
};

//-------------------------------------------------------------------------------------------------

Z.List = function( array, index ) {
	if( this == Z ) return new Z.List( array, index );
	this.byId = {};
	this.array = array || [];
	this.count = this.array.length;
	if( index ) this.index();
};

Z.List.prototype = {
	//dump: function( yields ) {
	//	this.each( yields || function( it, is ) {
	//		console.debug( is.index, it );
	//	});
	//},
	
	index: function() {
		var self = this;
		self.each( function( item ) {
			if( item.id ) self.byId[item.id] = item;
		});
	},
	
	push: function() {
		for( var i = 0, len = arguments.length;  i < len;  i++ ) {
			var item = arguments[i];
			if( item.id ) this.byId[item.id] = item;
			this.array[this.array.length] = item;
			this.count = this.array.length;
		}
	},
	
	join: function( sep ) {
		return this.array.join( sep != null ? sep : '' );
	},
	
	each: function( yields ) {
		var array = this.array, n = array.length, last = n - 1;
		var is = { first: true };
		for( var i = 0;  i < n;  ++i ) {
			is.index = i;
			if( i == last ) is.last = true;
			yields( array[i], is );
			delete is.first;
		}
		return n;
	},
	
	map: function( fn, that ) {
		var array = this.array, out = new Z.List;
		for( var i = 0, n = array.length;  i < n;  ++i ) {
			out.push( fn.call( that, array[i], i, n ) );
		}
		return out;
	},
	
	sort: function( key ) {
		this.array = Z.Array.sort( this.array, key );
	}
};

//-------------------------------------------------------------------------------------------------
// Zvents.Date - date/time utilities
//-------------------------------------------------------------------------------------------------
// We keep time in an unusual way: We pretend that UTC is our local time. For example, our
// "midnight" is midnight UTC, not midnight in your local time zone. This matches the server
// and lets us do time zone independent date searches.
//-------------------------------------------------------------------------------------------------

Z.Date = function( time ) {
	if( this === Z ) return new Z.Date( time );
	
	this.valid = Z.Date.dateStrict( time );
	this.date = this.valid  ||  Z.Date.dateNow();
};

Z.Date.prototype = {
	format: function( str ) {
		var self = this;
		return str.replace( /{(\w+)(:(\d+))?}/g,
			function( match, code, x, arg ) {
				return self[code] ? self[code](arg) : match;
			}
		);
	},

	// Formatters
	a: function() { return this.am().slice(0,1); },
	am: function() { return this.date.getUTCHours() < 12 ? 'am' : 'pm'; },
	D: function() { return this.date.getUTCDate(); },
	DD: function() { return Z.pad( this.D(), 2 ); },
	h: function() { return ( ( this.date.getUTCHours() + 11 ) % 12 + 1 ); }, 
	hh: function() { return Z.pad( this.h(), 2 ); },
	h24: function() { return this.date.getUTCHours(); }, 
	hh24: function() { return Z.pad( this.h24(), 2 ); },
	hmm: function() { return this.format( '{h}:{mm}&#160;{am}' ); },
	Jan: function() { return this.January().slice(0,3); },
	January: function() { return Z.Date.monthNames[ this.date.getUTCMonth() ]; },
	m: function() { return this.date.getUTCMinutes(); },
	mm: function() { return Z.pad( this.m(), 2 ); },
	M: function() { return this.date.getUTCMonth() + 1; },
	MM: function() { return Z.pad( this.M(), 2 ); },
	MDY: function() { return this.format( '{M}/{D}/{Y}' ); },
	s: function() { return this.date.getUTCSeconds(); },
	ss: function() { return Z.pad( this.s(), 2 ); },
	Sun: function() { return this.Sunday().slice(0,3); },
	Sunday: function() { return Z.Date.dayNames[ this.date.getUTCDay() ]; },
	Y: function() { return this.date.getUTCFullYear() },
	YMD: function() { return this.format( '{Y}-{MM}-{DD}' ); } //,
	
	//testFormat: function() {
	//	return this.format( '{a} {am} {D} {DD} {h} {hmm} {Jan} {January} {m} {mm} {M} {MM} {MDY} {s} {ss} {Sun} {Sunday} {Y} {YMD}' );
	//}
};

Z.Object.update( Z.Date, {
	oneSecond: 1000,
	oneMinute: 1000 * 60,
	oneHour:   1000 * 60 * 60,
	oneDay:    1000 * 60 * 60 * 24,
	oneWeek:   1000 * 60 * 60 * 24 * 7,
	
	dayNames: [
		'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
	],
	
	monthNames: [
			'January', 'February', 'March', 'April', 'May', 'June',
			'July', 'August', 'September', 'October', 'November', 'December'
	],
	
	// Create a Date object from a numeric or string time
	// Pass a numeric time straight through.
	// String time can be '20061231', '2006-12-31', or "Sun Dec 31 12:01:00 PDT 2006"
	// Always returns a Date object, defaulting to now if a string time can't be parsed
	date: function( time ) {
		return Z.Date.dateStrict( time )  ||  Z.Date.dateNow();
	},
	
	// Same as Z.Date.date, but returns null for a bad string time value
	dateStrict: function( time ) {
		var date = (function( time ) {
			try {
				if( ! time ) return;
				
				if( typeof time == 'number' ) {
					if( time < 100000000000 ) time *= 1000;  // handle time in seconds or milliseconds
					return new Date( time );
				}
				
				if( typeof time == 'object' ) {
					if( time.getTime ) return new Date( time.getTime() );  // Date
					if( time.date && time.valid ) return new Date( time.date.getTime() );  // Zvents.Date
				}
				
				if( typeof time != 'string' ) return;
				time = Z.String.trim( time );
				
				// Wed Jan 31 12:30:45 GMT 2007
				var m = time.match( /^[a-z]{3} ([a-z]{3}) (\d{2}) (\d{2}):(\d{2}):(\d{2}) \w{3} (\d{4})$/i );
				if( m ) return new Date( Date.UTC( +m[6], Z.Date.numberFromShortMonth(m[1]), +m[2], +m[3], +m[4], +m[5] ) );
				
				// Jan 2, 2007
				var m = time.match( /^([a-z]+)\s*(\d+)\s*,?\s*(\d+)$/i );
				if( m ) {
					var mon = Z.Date.numberFromShortMonth( m[1] );
					if( mon != null )
						return new Date( Date.UTC( +m[3], mon, +m[2] ) );
				}
				
				// 2007-01
				// 2007-01-31 
				// 2007-01-31 12:30
				// 2007-01-31 12:30:45
				var m = time.match( /^(\d{4})-(\d{2})(-(\d{2})( (\d{2}):(\d{2})(:(\d{2}))?)?)?$/ );
				if( m ) return new Date( Date.UTC( +m[1], m[2]-1, +m[4] || 1, +m[6] || 0, +m[7] || 0, +m[9] || 0 ) );
				
				// 20070131
				var m = time.match( /^(\d{4})(\d{2})(\d{2})$/ );
				if( m ) return new Date( Date.UTC( m[1], m[2]-1, m[3] ) );
			}
			catch( e ) {
			}
		})( time );
		
		return date && ! isNaN( date.getTime() ) ? date : null;
	},
	
	// Do the same as "new Date()", but treat time as local/UTC
	dateNow: function() {
		var date = new Date;
		return new Date( date.getTime() - date.getTimezoneOffset() * Z.Date.oneMinute );
	},
	
	time: function( time ) {
		return Z.Date.date(time).getTime();
	},
	
	now: function() {
		return Z.Date.dateNow().getTime();
	},
	
	midnight: function( time ) {
		return Z.Date.date(time).setUTCHours( 0, 0, 0, 0 );
	},
		
	today: function() {
		return Z.Date.midnight( Z.Date.now() );
	},
	
	isToday: function( time ) {
		return Z.Date.midnight(time) == Z.Date.today();
	},
	
	formatNumberDate: function( time, sep ) {
		return Z.Date(time).format( [ '{Y}', '{MM}', '{DD}' ].join( sep != null ? sep : '-' ) );
	},
	
	formatMdyDate: function( time, sep ) {
		return Z.Date(time).format( [ '{M}', '{D}', '{Y}' ].join( sep != null ? sep : '/' ) );
	},
	
	formatNumberMonth: function( time, sep ) {
		return Z.Date(time).format( [ '{Y}', '{MM}' ].join( sep != null ? sep : '-' ) );
	},
	
	formatLongDate: function( time, weekDay ) {
		return Z.Date(time).format(
			( weekDay ? '{Sunday}, ' : '' ) +
			'{January} {D}, {Y}'
		);
	},

	formatMonthYear: function( time ) {
		return Z.Date(time).format( '{January} {Y}' );
	},
	
	formatCalendarDate: function( time ) {
		return Z.Date(time).format( '{Jan} {D}' );
	},
	
	formatWeekDay: function( time ) {
		return Z.Date(time).format( '{Sunday}' );
	},
	
	formatShortTime: function( time ) {
		return Z.Date(time).hmm();
	},
	
	formatTimeRange: function( first, last ) {
		first = Z.Date.formatShortTime( first );
		if( ! last ) return first;
		last = Z.Date.formatShortTime( last );
		return first + '&#8211;' + last;
	},

	numberFromShortMonth: function( shortMonth ) {
		var months = {
			Jan:0, Feb:1, Mar:2, Apr:3, May:4, Jun:5,
			Jul:6, Aug:7, Sep:8, Oct:9, Nov:10, Dec:11
		};
		return months[shortMonth.slice(0,3)];
	}
});

//-------------------------------------------------------------------------------------------------

Z.unescape = function( str ) {
	return unescape( str || '' ).replace( /\+/g, ' ' );
};

Z.urlEscape = function( str ) {
	return str.replace( /&/g, "&amp;" );
};

Z.htmlEscape = function( str ) {
	return str/*.replace( /&/g, "&amp;" )*/
		.replace( /\"/g, "&quot;" )
		.replace( />/g, "&gt;" )
		.replace( /</g, "&lt;" );
};

Z.htmlFix = function( str ) {
	return Z.htmlEscape( Z.unescape(str) );
};

//Z.fullFormat = function( text ) {
//	return Z.autoLinkUrls( Z.autoLinkEmailAddresses( Z.miniFormat( text ) ) );
//};

//Z.miniFormat = function( text ) {
//	return Z.simpleFormat( Z.htmlEscape( text ) );
//};

//Z.simpleFormat = function( str ) {
//return [
//		'<p>',
//			str.replace( /(\r\n|\n|\r)/g, "\n" )
//				.replace( /\n\n+/g, "\n\n" )
//				.replace( /\n\n/g, '</p><p>' )
//		      .replace( /([^\n])(\n)([^\n])/g, '$1$2<br />$3' ),
//		'</p>'
//	].join('');
//};

//Z.autoLinkUrls = function( str ) {
//	var re = Z.autoLinkUrls.re;
//	if( ! re ) return str;
//	var out = [];
//	var m;
//	var last = 0;
//	while( ( m = re.exec(str) ) ) {
//		out[out.length] = str.slice( last, m.index );
//		out[out.length] = format( m[0], m[1], m[2], m[3], m[4], m[5] );
//		last = re.lastIndex;
//	}
//	out[out.length] = str.slice( last );
//	return out.join('');
//
//	function format( all, a, b, c, d, e ) {
//		if( a.search( /<a\s/i ) >= 0 ) return all;  // don't replace URL's that are already linked
//		var text = b + c;
//		if( b == "www." ) b = "http://www.";
//		return [ a, '<a href="', Z.linkToSite(b+c), '">', text, '</a>', e ].join('');
//	}
//};

//if( ! Z.browser.msie  ||  Z.browser.msie >= 5.5 )
//	Z.autoLinkUrls.re = new RegExp( '(<\\w+.*?>|[^=!:' + "'" + '"\\/]|^)((?:http[s]?:\\/\\/)|(?:www\\.))(([\\w]+[=?&\\/.-]?)*\\w+[\\/]?(?:\\#\\w*)?)([^\\w0-9A-Za-z]|\\s|<|$)', 'g' );

//Z.autoLinkEmailAddresses = function( str ) {
//	return str.replace(
//		/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/g,
//		'<a href="mailto:$1">$1</a>' );
//};

Z.pad = function( v, n ) {
	return n == null ? v : ( 1000000000000000 + v + '' ).slice( -n );
},

Z.addScript = function( url ) {
	//$('head',document).append(
	//	$.SCRIPT({ type:'text/javascript', charset:'utf-8', src:url })
	//);
	var script = document.createElement( 'script' );
	script.type = 'text/javascript';
	script.charset = 'utf-8';
	script.src = url;
	document.body.appendChild( script );
	return script;
};

function valueOfId() {
	return this.id;
}

Z.url = function( base, params ) {
	var p = Z.joinProps( params, '=', '&' );
	return p ? [ base, p ].join('?') : base;
};

Z.joinProps = function( params, pair, delim ) {
	var a = [];
	for( var p in params ) {
		if( typeof Object.prototype[p] == 'undefined' ) {
			var v = params[p];
			if( v != null ) a[a.length] = [ p, v ].join(pair);
		}
	}
	return a.sort().join(delim);
};

//Z.linkToEvent = function( event ) {
//	return Z.link({ event:event });
//};

//Z.linkToEmailEvent = function( event ) {
//	return Z.linkToEmail( Z.htmlEscape(event.name), Z.linkToEvent(event) );
//};

//Z.linkToEmail = function( subject, url ) {
//	return [ 'mailto:?subject=', subject, '&body=', url ].join('');
//};

//Z.link = function( params, options ) {
//	params = params || {};
//	var p = params;
//	if( ! p.url ) {
//		var base = p.base || ( cobrand && cobrand.url ) || location.href.split('?')[0];
//		delete p.base;
//		p = cobrand ? {} : Z.Object.copy( Z.hostParams );
//		for( var name in params ) if( typeof Object.prototype[name] == 'undefined' ) if( params[name] != null ) p[ Z.paramName(name) ] = params[name];
//		if( p.date ) p.date = Z.Date.formatNumberDate( p.date );
//		p.url = Z.linkParams( base, p );
//	}
//	return p.url;
//};

Z.linkParams = function( base, params ) {
	return Z.url( ( base || '' ).replace( /\?[^\?]*$|$/, '' ), params );
};

//// TODO: combine these?
//Z.linkEventName = function( event, max ) {
//	if( ! event || ! event.name ) return '';
//	var name = event.name;
//	if( max ) name = Z.String.truncate( name, max );
//	name = Z.htmlEscape( name );
//	return [ '<a href="', Z.linkToEvent(event), '">', name, '</a>' ].join('');
//};

//Z.linkVenueName = function( venue ) {
//	if( ! venue || ! venue.name ) return '';
//	var name = Z.htmlEscape( venue.name );
//	var url = Z.linkToVenue( venue );
//	return url ?
//		[ '<a href="', url, '">', name, '</a>' ].join('') :
//		name;
//};

//Z.linkEventImage = function( event, link ) {
//	try { var image = event.images[0]; } catch( e ) {}
//	return ! image ? '' : [
//		'<a class="ZventsEventImageLink"',
//			link !== false ? ' href="' + Z.linkToEvent(event) + '"' : '',
//		'>',
//			'<img class="ZventsEventImage" alt="Event image" border="0" ',
//				'src="', Z.imgThumb(image.url), '" ',
//				//'width="', image.width, '" height="', image.height, '" ',
//			'/>',
//		'</a>'
//	].join('');
//};

//Z.linkToVenue = function( venue ) {
//	return Z.link({ venue:venue, url:venue.url });
//};

//Z.linkToSite = function( url ) {
//	return Z.link({ url:url });
//};

function argtime( time ) {
	return Z.Date.time(time) / 1000 + '';
}

// Temp hack to add _thumb
Z.imgThumb = function( url ) {
	return url.replace( /_thumb\./, '.' ).replace( /\.([^.]+)$/, '_thumb.$1' );
};

Z.imgUrl = function ( file ) {
	return [ Z.imageBaseUrl, 'images/', file ].join('');
};

Z.imgTag = function( attrs ) {
	var src = attrs.src;
	if( Z.useIePng(src) ) {
		attrs.src = Z.imgUrl('spacer.png');
		attrs.style = [ ( attrs.style || '' ), 'filter:', Z.ieImgFilter(src) ].join('');
	}
	return Z.tag( 'img', attrs );
};

Z.setImg = function( img, src ) {
	if( Z.useIePng(src) ) img.style.filter = Z.ieImgFilter( src );
	else img.src = src;
};

Z.ieImgFilter = function( src ) {
	return [
		"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='", src, "', sizingMethod=scale);"
	].join('');
};

Z.useIePng = function( src ) {
	return Z.browser.iePngHack  &&  src.search(/\.png$/i) > 0;
};

Z.tag = function( tag, attrs ) {
	var html = [ '<' + tag ];
	for( var name in attrs ) {
		if( typeof Object.prototype[name] == 'undefined' ) {
			var value = attrs[name];
			name = { Class:'class' }[name] || name;
			html[html.length] = [ name, '="', value, '"' ].join('');
		}
	}
	html[html.length] = '/>';
	return html.join(' ');
};

function capitalize( text ) {
	return text.charAt(0).toUpperCase() + text.substr(1);
}

//-------------------------------------------------------------------------------------------------

Z.Dom = {};

Z.Dom.on =
	document.addEventListener ?
		function( e, type, handler ) { e.addEventListener( type, handler, false ) } :
		function( e, type, handler ) { e.attachEvent( 'on' + type, handler ); };

Z.Dom.off =
	document.removeEventListener ?
		function( e, type, handler ) { e.removeEventListener( type, handler, false ) } :
		function( e, type, handler ) { e.detachEvent( 'on' + type, handler ); };

(function() {
	var waiting  = [];
	var listen = Z.browser.mozilla || Z.browser.opera;
	if( listen )
		document.addEventListener( 'DOMContentLoaded', go, false );
	else
		poll();
	
	Z.Dom.on( window, 'load', go );
	
	function go() {
		Z.Dom.off( window, 'load', go );
		if( listen )
			document.removeEventListener( 'DOMContentLoaded', go, false );
		for( var i = 0;  i < waiting.length;  ++i )
			waiting[i]();
		waiting = null;
	}
	
	function poll() {
		try {
			if( Z.browser.msie  ||  document.readyState != 'loaded'  &&  document.readyState != 'complete' )
				document.documentElement.doScroll( 'left' );
			go();
		}
		catch( e ) {
			setTimeout( poll, 50 );
		}
	}
	
	Z.Dom.ready = function( yields ) {
		waiting ? waiting.push(yields) : yields();
	};
})();

//-------------------------------------------------------------------------------------------------

Z.Cookie = {
	read: function( name ) {
		var match = document.cookie.match( new RegExp( name + '=([^;]+)' ) );
		return match && unescape( match[1] );
	},
	
	write: function( name, value ) {
		document.cookie = name + '=' + escape( value );
	}
};

//-------------------------------------------------------------------------------------------------

Z.session = ( function() {
	var name = 'Zvents';
	var value = Z.Cookie.read( name );
	if( ! value ) {
		value = Z.Number.randomString( 10, 36 );
		Z.Cookie.write( name, value );
	}
	return value;
})();

//-------------------------------------------------------------------------------------------------

Z.jsons = {};

Z.jsonUrl = function( name, a ) {
	if( a.cat || a.what || a.when || a.where ) a.search = 'true';
	a.jsonsp = name;
	return [ Z.url( Z.site + '/json', a ), '&sid=', Z.session ].join('');
};

Z.loadJson = function( a ) {
	var url = Z.jsonUrl( a.name, a.load );
	var json = Z.jsons[url];
	if( json ) return a.yields( json );
	
	Z.Dom.ready( function() {
		window[a.name] = function( json ) {
			function callback( j ) { json = j; }
			eval( json );
			Z.jsons[url] = json;
			a.yields( json );
			window[a.name] = null;
			script.parentNode.removeChild( script );
		};
		
		var script = Z.addScript( url );
	});
};

//-------------------------------------------------------------------------------------------------

Z.EventList = function( args ) {
	var events = new Z.List;
	var venues = new Z.List;
	
	Z.loadJson({
		name: 'Zvents_load_' + args.id,
		load: args.load,
		yields: ready
	});
		
	function ready( json ) {
		try {
			var rsp = json.rsp;
			switch( rsp.status ) {
			case 'error':
				var error = events.error = venues.error = rsp.msg;
				break;
			case 'ok':
				var content = rsp.content;
				
				var eventArray = events.array = content.events || [];
				var venueArray = venues.array = content.venues || [];
				events.repeats = 0;
				events.total = content.event_count;
				venues.total = content.venue_count;
				
				for( var v = 0, n = venueArray.length;  v < n;  v++ ) {
					var venue = venueArray[v];
					venue.valueOf = valueOfId;
					venue.events = [];
					venues.byId[venue.id] = venue;
				}
				venues.count = venueArray.length;
				
				for( var e = 0, n = eventArray.length;  e < n;  e++ ) {
					var event = eventArray[e];
					event.valueOf = valueOfId;
					events.byId[event.id] = event;
					var venue = event.venue = venues.byId[event.vid];
					if( venue ) {
						if( venue.parent_id ) venue = event.venue = venues.byId[venue.parent_id];
						if( venue ) {
							venue.events[venue.events.length] = event;
						}
					}
					event.starttime = Z.Date.time( event.startTime );
					event.date = Z.Date.midnight( event.starttime );
					if( event.endTime ) event.endtime = Z.Date.time( event.endTime );
					event.zurl = Z.site + event.zurl;
				}
				events.count = eventArray.length;
				
				args.yields( events );
				break;
			}
		}
		catch( e ) {
		}
		finally {
		}
	}
};

//-------------------------------------------------------------------------------------------------
// End of ZventsMini --> Z renaming function
//-------------------------------------------------------------------------------------------------

})( ZventsMini );

//-------------------------------------------------------------------------------------------------
// End of Zvents calendar widgets
//-------------------------------------------------------------------------------------------------