zvents_save_jquery = {};
if (typeof jQuery != 'undefined') zvents_save_jquery.jQuery = jQuery; 
if (typeof $ != 'undefined') zvents_save_jquery.$ = $;
if (typeof Zvents == "undefined") {
    Zvents = {};
}

if (typeof ZWidgets == "undefined") {
    ZWidgets = {};
	 
    if (typeof $ZJQuery == "undefined") {
        $ZJQuery = jQuery.noConflict();
    }
		(function ($, Z) {
        Z._doc_ready = false;
        $(function () {
            Z._doc_ready = true;
        });
        Z.Array = {
            map: function (a, f) {
                var m = [];
                for (i = 0; i < a.length; i++) {
                    m[i] = f(a[i]);
                }
                return m;
            },
            mapWithIndex: function (a, f) {
                var m = [];
                for (i = 0; i < a.length; i++) {
                    m[i] = f(a[i], i);
                }
                return m;
            },
            sort_by_property: function (a, prop) {
                function prop_cmp(x, y) {
                    if (x[prop] == y[prop]) {
                        return 0;
                    }
                    if (x[prop] > y[prop]) {
                        return 1;
                    }
                    else {
                        return -1;
                    }
                }
                a.sort(prop_cmp);
            }
        };
        Z.Object = {
            bindMethod: function (that, f) {
                return function () {
                    return f.apply(that, arguments);
                };
            },
            update: function (self) {
                return Z.Object.updateFromArray(self, arguments, 1);
            },
            clone: function (obj) {
                if (obj && typeof obj == 'object') {
                    var new_obj = {};
                    Z.Object.update(new_obj, obj);
                    obj = new_obj;
                }
                return obj;
            },
            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];
                                var b = obj[prop];
                                if (a && typeof a == 'object' && b && typeof b == 'object') {
                                    Z.Object.update(a, b);
                                }
                                else {
                                    self[prop] = Z.Object.clone(b);
                                }
                            }
                        }
                    }
                }
                return self;
            }
        };
        Z.String = {
            trim: function (s) {
                var m = s.match(/^\s*(.*)\s*$/);
                return m ? m[1] : '';
            },
            truncate: function (s, n) {
                var truncated = false;
                if (typeof s != 'string') {
                    return '';
                }
                var len = s.length;
                var ts = "";
                if (typeof n == 'number' && n < len) {
                    n -= 2;
                    var si = 0;
                    while (si < s.length) {
                        var word = "";
                        while (si < s.length && word.indexOf(' ') == -1) {
                            word += s.substr(si, 1);
                            si++;
                        }
                        if ((word.length + ts.length) <= n) {
                            ts += word;
                        }
                        else {
                            if (ts.substr(ts.length - 1, 1) == ' ') {
                                ts = ts.substr(0, ts.length - 1);
                            }
                            truncated = true;
                            break;
                        }
                    }
                }
                else {
                    ts = s;
                }
                if (truncated) {
                    if (ts.length === 0) {
                        ts = s.substr(0, n);
                    }
                    ts += '&#8230;';
                }
                return ts;
            },
            hash: function (s) {
                var hash = 5381;
                for (i = 0; i < s.length; i++) {
                    hash = ((hash << 5) + hash) + s.charCodeAt(i);
                }
                return Math.abs(hash);
            },
            toOrdinal: function (i) {
                var sfx = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th'];
                return i + (($.inArray(i % 100, [11, 12, 13]) == -1) ? sfx[i % 10] : 'th');
            }
        };
        Z.Image = {
            thumbUrl: function (url) {
                return url.replace(/_thumb\./, '.').replace(/\.([^.]+)$/, '_thumb.$1');
            }
        };
        Z.Date = function (time) {
            if (this === ZWidgets) {
                return new Z.Date(time);
            }
            this.valid = Z.Date.dateStrict(time);
            this.date = this.valid || Z.Date.dateNow();
            return this;
        };
        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;
                });
            },
            a: function () {
                return this.am().slice(0, 1);
            },
            A: function () {
                return this.a().toUpperCase();
            },
            am: function () {
                return this.date.getUTCHours() < 12 ? 'am' : 'pm';
            },
            AM: function () {
                return this.am().toUpperCase();
            },
            Dth: function () {
                return Z.String.toOrdinal(this.date.getUTCDate());
            },
            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}');
            }
        };
        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'],
            date: function (time) {
                return Z.Date.dateStrict(time) || Z.Date.dateNow();
            },
            dateStrict: function (time) {
                var date = (function (time) {
                    try {
                        if (!time) {
                            return null;
                        }
                        if (typeof time == 'number') {
                            if (time < 100000000000) {
                                time *= 1000;
                            }
                            return new Date(time);
                        }
                        if (typeof time == 'object') {
                            if (time.getTime) {
                                return new Date(time.getTime());
                            }
                            if (time.date && time.valid) {
                                return new Date(time.date.getTime());
                            }
                        }
                        if (typeof time != 'string') {
                            return null;
                        }
                        time = Z.String.trim(time);
                        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]));
                        }
                        m = time.match(/^([a-z]+)\s*(\d+)\s*,?\s*(\d+)$/i);
                        if (m) {
                            var mon = Z.Date.numberFromShortMonth(m[1]);
                            if (typeof mon != "undefined") {
                                return new Date(Date.UTC(+m[3], mon, +m[2]));
                            }
                        }
                        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));
                        }
                        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) {}
                    return null;
                })(time);
                return date && !isNaN(date.getTime()) ? date : null;
            },
            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(typeof sep != "undefined" ? sep : '-'));
            },
            formatMdyDate: function (time, sep) {
                return Z.Date(time).format(['{M}', '{D}', '{Y}'].join(typeof sep != "undefined" ? sep : '/'));
            },
            formatNumberMonth: function (time, sep) {
                return Z.Date(time).format(['{Y}', '{MM}'].join(typeof sep != "undefined" ? 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;
                }
                else {
                    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)];
            },
            addDaysAtMidnight: function (time, days) {
                time = Z.Date.midnight(time);
                if (typeof days == 'function') {
                    days = days(time);
                }
                var date = Z.Date.date(time);
                return date.setUTCDate(date.getUTCDate() + days);
            },
            nextWeek: function (time) {
                return Z.Date.addDaysAtMidnight(time, 7);
            },
            nextDay: function (time) {
                return Z.Date.addDaysAtMidnight(time, 1);
            },
            beginWeek: function (time) {
                return Z.Date.beginPeriod(time, 'getUTCDay', 0);
            },
            beginMonth: function (time) {
                return Z.Date.beginPeriod(time, 'getUTCDate', 1);
            },
            beginPeriod: function (time, getter, first) {
                var date = Z.Date.date(time);
                return Z.Date.addDaysAtMidnight(time, function (time) {
                    return first - date[getter]();
                });
            },
            isWeekend: function (time) {
                var date = Z.Date.date(time);
                switch (date.getUTCDay()) {
                case 0:
                case 6:
                    return true;
                default:
                    return false;
                }
            },
            isToday: function (time) {
                return Z.Date.midnight(time) == Z.Date.today();
            },
            firstWeekOfMonth: function (time) {
                return Z.Date.beginWeek(Z.Date.beginMonth(time));
            },
            addMonth: function (time, incr) {
                var date = Z.Date.date(Z.Date.beginMonth(time));
                return date.setUTCMonth(date.getUTCMonth() + incr);
            }
        });
        Z.Object.update(ZWidgets, {
            widgets: {},
            configMerge: function (to_config, in_config) {
                if (!to_config) {
                    to_config = {};
                }
                for (param in in_config) {
                    if (to_config[param] && typeof to_config[param] == "object") {
                        arguments.callee(to_config[param], in_config[param]);
                    }
                    else {
                        to_config[param] = in_config[param];
                    }
                }
            },
            overrideRenderers: function (widget, renderers) {
                for (var renderer in renderers) {
                    if (renderer.substring(0, 6) == "render" && typeof widget[renderer] == "function") {
                        widget[renderer] = renderers[renderer];
                    }
                    else {
                        throw "Invalid renderer: " + renderer;
                    }
                }
            },
            pad: function (v, n) {
                return !n ? v : (1000000000000000 + v + '').slice(-n);
            }
        });

        function Loader() {
            this.jsons_cache = {};
            this.jsonp_fun_cache = {};
            this.request_cnt = 0;
        }
        Loader._callback_count = 0;
        Loader.prototype = {
            json: function (url, params, cb) {
                var self = this;
                var url_and_params = url + $.param(params);
                var json = self.jsons_cache[url_and_params];
                if (typeof json != "undefined") {
                    Z.defer(function () {
                        cb(json);
                    });
                    return;
                }
                var jsonp_fun = self.jsonp_fun_cache[url_and_params];
                if (jsonp_fun) {
                    var prev_jsonp = jsonp_fun;
                    var new_jsonp = function (response) {
                        function callback(json) {
                            $(document).bind('jsonp-callback', function () {
                                Z.defer(function () {
                                    cb(json)
                                });
                                self.jsons_cache[full_url] = json;
                            }).trigger('jsonp-callback');
                        }
                        eval(response);
                        prev_jsonp(response);
                    };
                    new_jsonp.jsonp_name = prev_jsonp.jsonp_name;
                    self.jsonp_fun_cache[url_and_params] = window[jsonp_fun.jsonp_name] = new_jsonp;
                    return;
                }
                var jsonp_name = 'jsp_' + Loader._callback_count;
                Loader._callback_count++;

                function loadScript() {
                    params.jsonsp = jsonp_name;
                    var full_url = url + '?' + $.param(params);
                    var jsonp_fun = function (response) {
                        function callback(json) {
                            self.jsons_cache[url_and_params] = json;
                            Z.defer(function () {
                                cb(json);
                            });
                        }
                        eval(response);
                        window[jsonp_name] = null;
                        self.jsonp_fun_cache[url_and_params] = null;
                        $('head script:last').remove();
                    };
                    jsonp_fun.jsonp_name = jsonp_name;
                    window[jsonp_name] = jsonp_fun;
                    var script = document.createElement('script');
                    script.type = 'text/javascript';
                    script.charset = 'utf-8';
                    script.src = full_url;
                    document.body.appendChild(script);
                }
                if (Z._doc_ready) {
                    loadScript();
                }
                else {
                    $(function () {
                        loadScript();
                    });
                }
            }
        };
        Z.Ajax = {
            loader: new Loader(),
            loadJson: function (url, params, callback, errback) {
                return Z.Ajax.loader.json(url, params, callback, errback);
            }
        };
        Z.Css = {
            addRules: function (rules) {
                var cssBlocks = [];
                for (rule in rules) {
                    cssBlocks.push(rule + "{" + rules[rule] + "}");
                }
                var styleEl = document.createElement('style');
                styleEl.setAttribute("type", "text/css");
                if (styleEl.styleSheet) {
                    styleEl.styleSheet.cssText = cssBlocks.join('');
                } else {
                    styleEl.appendChild(document.createTextNode(cssBlocks.join('')));
                }
                document.getElementsByTagName('head')[0].appendChild(styleEl);
            }
        };
        var _deferCount = 0;
        window['_z_deferFire'] = function (i) {
            $(document).trigger('defer-event-' + i);
        };
        Z.defer = function (cb) {
            $(document).bind('defer-event-' + _deferCount, cb);
            setTimeout('_z_deferFire(' + _deferCount + ')', 0);
            _deferCount++;
        };
        Z.onDocReady = function (cb) {
            if (Z._doc_ready) {
                cb();
            }
            else {
                $(cb);
            }
        };
    })($ZJQuery, ZWidgets);
}

(function ($, Z) {
    if (typeof Z.widgets.QuickDayCalendar == "undefined") {
        var widget = function (config) {
            this.settings = {
                site: 'http://calendar.fresnobee.com',
                n_days: 7,
                day_images: null,
                search_params: {
                    swhat: '',
					swhere: 'Fresno, CA',
                    st: 'event'
                },
                labels: {
                    days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
                    months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
                    today: 'Today',
                    tomorrow: 'Tomorrow',
                    all: 'All',
                    events: 'events',
                    title_preamble: 'View events for ',
                    title_anyday: 'View events for any day'
                },
                classes: {
                    list: 'ZventsQuickDayList',
                    item: '',
                    button: 'ZventsDayButton',
                    date_label: 'ZventsDayButtonDate',
                    day_label: 'ZventsDayButtonDay',
                    today_button: 'ZventsDayButtonToday',
                    weekend_button: 'ZventsDayButtonWeekend',
                    all_button: 'ZventsAllButton',
                    top_span: 'ZventsDayButtonDate',
                    bottom_span: 'ZventsDayButtonDay'
                },
                inline: true
            }
            Z.Object.update(this.settings, config);
            if (this.settings.renderers) {
                Z.overrideRenderers(this, this.settings.renderers);
            }
            this.search_url = this.settings.site + '/search?' + $.param(this.settings.search_params) + '&swhen={day}';
            if (this.settings.inline) {
                document.write(this.render());
            }
        }
        widget.prototype = {
            render: function () {
                return ['<ul class="' + this.settings.classes.list + '">', this.renderButtons(), '</ul>', '<div style="clear: both"></div>'].join('');
            },
            renderButtons: function () {
                var element_class = '';
                var today_class = this.settings.classes.today;
                var buttons = [];
                var date = new Date((new Date).setHours(0, 0, 0, 0));
                for (var i = 1; i <= this.settings.n_days; ++i) {
                    buttons.push(this.renderButton(date, i));
                    date.setDate(date.getDate() + 1);
                }
                buttons.push(this.renderButton(null, -1));
                return buttons.join('');
            },
            renderButton: function (date, i) {
                var is_today = (i == 1);
                var button_class = this.settings.classes.button;
                var title;
                var top_span;
                var bottom_span;
                var day_label;
                var url;
                if (date) {
                    var day_of_month = date.getDate();
                    var day_of_week = date.getDay();
                    var is_weekend = (day_of_week == 0 || day_of_week == 6);
                    var year = date.getFullYear();
                    var month_label = this.settings.labels.months[date.getMonth()];
                    var day_label = this.settings.labels.days[day_of_week];
                    title = this.settings.labels.title_preamble + day_label + ', ' + month_label + ' ' + day_of_month + ', ' + year;
                    top_span = day_of_month;
                    bottom_span = day_label.slice(0, 3);
                    url = this.search_url.replace(/{day}/, i == 1 ? this.settings.labels.today : i == 2 ? this.settings.labels.tomorrow : day_label);
                    if (is_today) {
                        button_class += ' ' + this.settings.classes.today_button;
                    }
                    if (is_weekend) {
                        button_class += ' ' + this.settings.classes.weekend_button;
                    }
                }
                else {
                    title = this.settings.labels.title_anyday;
                    top_span = this.settings.labels.all;
                    bottom_span = this.settings.labels.events;
                    url = this.settings.site;
                    button_class += ' ' + this.settings.classes.all_button;
                }
                if (this.settings.day_images) {
                    var image = this.settings.day_images[date.getDay()];
                    return ['<li>', '<a href="', url, '" ', 'class="', button_class, '" ', 'title="', title, '" ', '>', '<img src="', image, '" width="35" height="30" border="0" ', 'alt="', title, '" ', 'title="', title, '" ', '/>', '</a>', '</li>'].join('');
                }
                else {
                    return ['<li>', '<a href="', url, '" ', 'class="', button_class, '" ', 'title="', title, '" ', '>', '<span class="', this.settings.classes.top_span, '">', '&nbsp;', top_span, '&nbsp;', '</span>', '<span class="', this.settings.classes.bottom_span, '">', bottom_span, '</span>', '</a>', '</li>'].join('');
                }
            }
        }
        Z.widgets.QuickDayCalendar = widget;
    }
})($ZJQuery, ZWidgets);


(function ($, Z) {
    if (typeof Z.widgets.EventList == "undefined") {
        var default_settings = {
            id: null,
            partner_id: 171,
            venues_only: false,
            show_images: false,
            show_date: true,
            max_title: 40,
            max_venue_name: 40,
            sort: true,
            site: 'http://calendar.fresnobee.com',
            method: 'search',
            hide_on_empty: false,
            include_quantcast: true,
            disable_shuffling: false,
            links_open_new_window: false,
            labels: {
                loading: 'Loading&#8230;',
                sponsored: 'Sponsored',
                today: 'today',
                tomorrow: 'tomorrow',
                prompt_tickets_now: 'ON SALE NOW',
                prompt_tickets_future: 'ON SALE {day}',
                ticket_icon: 'Ticket'
            },
            classes: {
                block: 'ZventsEventList',
                loading: 'ZventsLoading',
                loading_text: 'ZventsTT',
                event_list: 'ZventsEventList',
                sponsored_label: 'ZventsSponsoredLabel',
                sponsored_list: 'ZventsSponsoredList',
                date: 'ZventsEventDate',
                event: 'ZventsEvent',
                event_time: 'ZventsEventTime',
                event_link: 'ZventsEventName',
                venue_link: 'ZventsEventName',
                venue: 'ZventsVenue',
                image_link: 'ZventsImageLink',
                image: 'ZventsImage',
                tickets_prompt: 'ZventsTicketsPrompt',
                ticket_icon: 'ZventsTicketIcon',
                ticket_icon_link: 'ZventsTicketIcon'
            },
            images: {
                spinner: 'http://images.zvents.com/images/spinner16.gif',
                ticket_icon: null
            },
            selector: null,
            inline: true,
            load: {
                spn_limit: 1
            },
            image_width: 66,
            image_height: 66,
            base_css: {
                ".ZventsEventList, .ZventsSponsoredList": "list-style-type: none;margin: 0;padding: 3px;width: auto",
                ".ZventsSponsoredLabel": "color: #888;font-weight:bold",
                ".ZventsSponsoredList": "border: solid 1px #ccc;",
                ".ZventsEventList li": "display: block;margin: 0;padding: 0;",
                ".ZventsSponsoredList li": "display: block;margin: 0;padding: 0;",
                ".ZventsImage": "margin: 3px;vertical-align: middle;",
                ".ZventsTicketsPrompt": "text-transform:uppercase"
            }
        };
        var el_link_count = 0;
        var method_cm_mapping = {
            search: "search",
            featured_events: "featured",
            hot_tickets: "hot_tickets",
            performer_events: "performer_events",
            recently_created: "recently_created",
            related_events: "related"
        };
        var widget = function (config) {
            var self = this;
            var undefined;
            this.settings = {};
            Z.Object.update(this.settings, default_settings);
            Z.Object.update(this.settings, config);
            if (this.settings.load.ssrss) {
                this.settings.load.spn_limit = this.settings.load.ssrss;
                delete this.settings.load['ssrss'];
            }
            if (this.settings.load.spn_limit < 1) this.settings.load.spn_limit = 1;
            if (!this.settings.disable_shuffling) {
                this.settings.load.rand_spn = this.settings.load.spn_limit * 5;
            }
            if (this.settings.renderers) {
                Z.overrideRenderers(this, this.settings.renderers);
            }
            Z.Css.addRules(this.settings.base_css);
            if (this.settings.css) {
                Z.Css.addRules(this.settings.css);
            }
            if (typeof this.settings.load.st == "undefined") {
                if (this.settings.venues_only) {
                    this.settings.load.st = "venue";
                }
                else {
                    this.settings.load.st = "event";
                }
            }
            this.url = this.settings.site + '/partner_json/' + this.settings.method;
            this.today = Z.Date.today();
            if (!this.settings.selector && this.settings.id) {
                this.selector = "#" + this.settings.id;
            }
            else {
                this.selector = this.settings.selector;
            }
            if (!this.selector) {
                throw new Error('Widget requires id or selector in config.');
            }
            else {
                this.settings.include_quantcast = false;
            }
            if (this.settings.inline) {
                document.write(this.render());
            }
        };

        function _isEmptyDataSet(data) {
            var content = data.content;
            return (!content.venue_count && !content.event_count && !content.sponsored_event_count);
        }
        widget.EV_EVENTS_LOADED = 'events-loaded';
        widget.prototype = {
            EV_EVENTS_LOADED: widget.EV_EVENTS_LOADED,
            load: function () {
                var self = this;
                Z.Ajax.loadJson(self.url, self.settings.load, Z.Object.bindMethod(self, self.loadResponse));
            },
            loadResponse: function (data) {
                var self = this;
                $(function () {
                    self.response = data.rsp;
                    switch (self.response.status) {
                    case 'error':
                        $(self.selector).html(self.renderError(self.response.msg));
                        break;
                    case 'ok':
                        self.link_to_item_map = {};
                        $(self.selector).html(self.renderListings(self.response));
                        break;
                    default:
                        $(self.selector).html('');
                        break;
                    }
                    $(self.selector).trigger(self.EV_EVENTS_LOADED);
                });
            },
            render: function () {
                html = this.renderLoading();
                if (this.settings.load) {
                    this.load();
                }
                return html;
            },
            renderError: function (error) {
                console.log(error);
            },
            prepareVenues: function (data) {
                var content = data.content;
                var venues = content.venues || [];
                var venue;
                venues.total = content.venue_count;
                venues.byId = {};
                for (var v = 0, n = venues.length; v < n; v++) {
                    venue = venues[v];
                    venue.sponsored = false;
                    venue.type = "venue";
                    venue.events = [];
                    venues.byId[venue.id] = venue;
                }
                if (typeof this.settings.load.limit != "undefined") {
                    venues = venues.splice(0, this.settings.load.limit);
                }
                return venues;
            },
            prepareEvent: function (event, venues) {
                var venue = event.venue = venues.byId[event.venue_id];
                if (venue) {
                    if (venue.parent_id) {
                        venue = event.venue = venues.byId[venue.parent_id];
                    }
                    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);
                }
                if (event.sponsored && event.tickets_on_sale) {
                    var on_sale_date = Z.Date.midnight(Z.Date.time(event.tickets_on_sale));
                    var delta = (this.today - on_sale_date);
                    if (delta <= 0) {
                        event.tickets_prompt = this.settings.labels.prompt_tickets_future.replace('{day}', this.renderDay(on_sale_date));
                    }
                    else if (delta < (Z.Date.oneDay * 14)) {
                        event.tickets_prompt = this.settings.labels.prompt_tickets_now;
                    }
                }
            },
            prepareEvents: function (data) {
                var content = data.content;
                var events = content.events || [];
                var sponsored_events = content.sponsored_events || [];
                var venues = content.venues || [];
                events.repeats = 0;
                events.total = content.event_count ? content.event_count : 0;
                sponsored_events.repeats = 0;
                sponsored_events.total = content.sponsored_event_count ? content.sponsored_event_count : 0;
                venues.total = content.venue_count;
                venues.byId = {};
                events.byId = {};
                sponsored_events.byId = {};
                var v, n, e, venue, event;
                for (v = 0, n = venues.length; v < n; v++) {
                    venue = venues[v];
                    venue.events = [];
                    venue.type = "venue";
                    venues.byId[venue.id] = venue;
                }
                for (e = 0, n = sponsored_events.length; e < n; e++) {
                    event = sponsored_events[e];
                    event.sponsored = true;
                    event.type = "event";
                    sponsored_events.byId[event.id] = event;
                    this.prepareEvent(event, venues);
                }
                for (e = 0, n = events.length; e < n; e++) {
                    event = events[e];
                    event.sponsored = false;
                    event.type = "event";
                    events.byId[event.id] = event;
                    this.prepareEvent(event, venues);
                }
                if (this.settings.sort) {
                    Z.Array.sort_by_property(sponsored_events, 'starttime');
                    Z.Array.sort_by_property(events, 'starttime');
                }
                if (typeof this.settings.max_displayed != "undefined" && (events.length + sponsored_events.length) > this.settings.max_displayed) {
                    if (sponsored_events.length >= this.settings.max_displayed) {
                        events = [];
                        if (sponsored_events.length > this.settings.max_displayed) {
                            sponsored_events.splice(this.settings.max_displayed, sponsored_events.length - this.settings.max_displayed);
                        }
                    }
                    else {
                        events.splice(this.settings.max_displayed - sponsored_events.length, events.length - (this.settings.max_displayed - sponsored_events.length));
                    }
                }
                return {
                    sponsored: sponsored_events,
                    organic: events
                };
            },
            renderListings: function (data) {
                if (this.settings.hide_on_empty && _isEmptyDataSet(data)) {
                    $(this.selector).hide();
                    return '';
                }
                else if (this.settings.venues_only) {
                    this.venues = this.prepareVenues(data);
                    return this.renderVenues(this.venues);
                }
                else {
                    this.events = this.prepareEvents(data);
                    return this.renderEvents(this.events);
                }
            },
            renderDay: function (date) {
				/*
                if (date == this.today) {
                    return this.settings.labels.today;
                }
                if (date == this.today + Z.Date.oneDay) {
                    return this.settings.labels.tomorrow;
                }
                else {
                    return Z.Date(date).format(date < this.today + Z.Date.oneDay * 7 ? '{Sunday}' : '{M}/{DD}');
                }
				*/
				return Z.Date(date).format('{Sunday}, {January} {D}');
            },
            renderDate: function (event) {
                if (this.settings.show_date === false) {
                    return '';
                }
                else {
                    return this.renderDay(event.date);
                }
            },
            renderTime: function (event) {
                if (this.settings.show_time === false) {
                    return '';
                }
                else {
                    var date = Z.Date(event.starttime);
                    var hours = date.date.getUTCHours();
                    var minutes = date.date.getUTCMinutes();
                    return date.format(minutes ? '{h}:{mm} {am}' : {
                        0: 'Midnight',
                        12: 'Noon'
                    }[hours] || '{h} {am}');
                }
            },
            listingLinkAttrs: function (listing, rank, sponsored) {
                el_link_count++;
                var link_id = "z_link_" + this.settings.id + '_' + el_link_count;
                this.link_to_item_map[link_id] = {
                    id: listing.id,
                    type: listing.type,
                    rank: rank,
                    sponsored: sponsored
                };
                return [' id="', link_id, '" href="', this.settings.site, listing.zurl, '" '].join("");
            },
            renderListingLink: function (listing, content, link_class) {
                if (!link_class) {
                    link_class = this.settings.classes.event_link;
                }
                return [, '<a ', this.settings.links_open_new_window ? ' target="_blank" ' : '', this.listingLinkAttrs(listing, listing.rank, listing.sponsored), ' class="', link_class, '" >', content, '</a>'].join("");
            },
            renderSponsoredLabel: function () {
                return ['<label class="', this.settings.classes.sponsored_label, '">', this.settings.labels.sponsored, '</label>'].join('');
            },
            renderEventName: function (event) {
                return this.renderListingLink(event, Z.String.truncate(event.name, this.settings.max_title));
            },
            renderEventVenueName: function (event) {
                return ['<a class="', this.settings.links_open_new_window ? ' target="_blank" ' : '', this.settings.classes.venue_link, '" ', this.listingLinkAttrs(event.venue, event.rank, event.sponsored), ' >', ZWidgets.String.truncate(event.venue.name, this.settings.max_venue_name), '</a>'].join('');
            },
            renderSponsoredEvent: function (event, i) {
                return this.renderEvent(event, i);
            },
            renderEvent: function (event, i) {
                var date = this.renderDate(event);
                if (date) {
                    date = ['<span class="', this.settings.classes.date, '">', date, '</span>', ' '].join('');
                }
                return ['<li class="', this.settings.classes.event, '">', this.settings.show_images ? this.renderImage(event) : '', '<span class="', this.settings.classes.event_time, '">', this.renderTime(event), '</span>', ' ', date, this.renderEventName(event), '</li>'].join('');
            },
            renderSponsoredEvents: function (events) {
                if (events && events.length > 0) {
                    return [this.renderSponsoredLabel(), '<ul class="', this.settings.classes.sponsored_list, '">', Z.Array.mapWithIndex(events, Z.Object.bindMethod(this, this.renderSponsoredEvent)).join(''), '</ul>'].join('');
                }
                else {
                    return '';
                }
            },
            renderOrganicEvents: function (events) {
                return ['<ul class="', this.settings.classes.event_list, '">', Z.Array.mapWithIndex(events, Z.Object.bindMethod(this, this.renderEvent)).join(''), '</ul>'].join('');
            },
            renderEvents: function (events) {
                return [this.renderSponsoredEvents(events.sponsored), this.renderOrganicEvents(events.organic)].join('');
            },
            renderVenue: function (venue, for_event) {
                var rank = for_event ? for_event.rank : venue.rank;
                var sponsored = for_event ? for_event.sponsored : venue.sponsored;
                return ['<li class="', this.settings.classes.venue, '">', this.settings.show_images ? this.renderImage(venue) : '', '<a ', this.settings.links_open_new_window ? ' target="_blank" ' : '', this.listingLinkAttrs(venue, rank, sponsored), ' class="', this.settings.classes.venue_link, '" >', Z.String.truncate(venue.name, this.settings.max_title), '</a>', '<br />at ', venue.address, ', ', venue.city, ', ', venue.state, '. ', venue.phone, '</li>'].join('');
            },
            renderVenues: function (venues) {
                return ['<ul class="', this.settings.classes.event_list, '">', Z.Array.map(venues, Z.Object.bindMethod(this, this.renderVenue)).join(''), '</ul>'].join('');
            },
            renderLoading: function () {
                return ['<div class="', this.settings.classes.loading, '">', '<img src="', this.settings.images.spinner, '" />', '<span class="', this.settings.classes.loading_span, '">', this.settings.labels.loading, '</span>', '</div>'].join('');
            },
            renderImg: function (src, width, height, title, image_class) {
                if (!src) return "";
                return ['<img class="', image_class, '" alt="', title, '" title="', title, '" border="0" src="', src, '" ', width ? ' width="' + width + '" ' : '', height ? ' height="' + height + '" ' : '', '/>'].join('');
            },
            renderTicketIcon: function (event) {
                if (event.has_tickets) {
                    return this.renderImgLink(event, this.settings.images.ticket_icon, null, null, this.settings.labels.ticket_icon, this.settings.classes.ticket_icon, this.settings.classes.ticket_icon_link);
                }
            },
            renderImgLink: function (event, src, width, height, title, image_class, image_link_class) {
                if (!src) return "";
                return this.renderListingLink(event, this.renderImg(src, width, height, title, image_class), image_link_class);
            },
            renderImage: function (event) {
                var image = event.images[0];
                if (image) {
                    return this.renderImgLink(event, image.url, this.settings.image_width, this.settings.image_height, 'image', this.settings.classes.image, this.settings.classes.image_link);
                }
                else {
                    return '';
                }
            }
        };
        Z.widgets.EventList = widget;
    }
})($ZJQuery, ZWidgets);
FresnobeeCalendar = ZWidgets.widgets;