1.sayfa sığmadığı için

(function($) { // Hide scope, no $ conflict

/* Countdown manager. */
function Countdown() {
this.regional = []; // Available regional settings, indexed by language code
this.regional[''] = { // Default regional settings
// The display texts for the counters
labels: ['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds'],
// The display texts for the counters if only one
labels1: ['Year', 'Month', 'Week', 'Day', 'Hour', 'Minute', 'Second'],
compactLabels: ['y', 'm', 'w', 'd'], // The compact texts for the counters
whichLabels: null, // Function to determine which labels to use
digits: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], // The digits to display
timeSeparator: ':', // Separator for time periods
isRTL: false // True for right-to-left languages, false for left-to-right
};
this._defaults = {
until: null, // new Date(year, mth - 1, day, hr, min, sec) - date/time to count down to
// or numeric for seconds offset, or string for unit offset(s):
// 'Y' years, 'O' months, 'W' weeks, 'D' days, 'H' hours, 'M' minutes, 'S' seconds
since: null, // new Date(year, mth - 1, day, hr, min, sec) - date/time to count up from
// or numeric for seconds offset, or string for unit offset(s):
// 'Y' years, 'O' months, 'W' weeks, 'D' days, 'H' hours, 'M' minutes, 'S' seconds
timezone: null, // The timezone (hours or minutes from GMT) for the target times,
// or null for client local
serverSync: null, // A function to retrieve the current server time for synchronisation
format: 'dHMS', // Format for display - upper case for always, lower case only if non-zero,
// 'Y' years, 'O' months, 'W' weeks, 'D' days, 'H' hours, 'M' minutes, 'S' seconds
layout: '', // Build your own layout for the countdown
compact: false, // True to display in a compact format, false for an expanded one
significant: 0, // The number of periods with values to show, zero for all
description: '', // The description displayed for the countdown
expiryUrl: '', // A URL to load upon expiry, replacing the current page
expiryText: '', // Text to display upon expiry, replacing the countdown
alwaysExpire: false, // True to trigger onExpiry even if never counted down
onExpiry: null, // Callback when the countdown expires -
// receives no parameters and 'this' is the containing division
onTick: null, // Callback when the countdown is updated -
// receives int[7] being the breakdown by period (based on format)
// and 'this' is the containing division
tickInterval: 1 // Interval (seconds) between onTick callbacks
};
$.extend(this._defaults, this.regional['']);
this._serverSyncs = [];
// Shared timer for all countdowns
function timerCallBack(timestamp) {
var drawStart = (timestamp < 1e12 ? // New HTML5 high resolution timer
(drawStart = performance.now ?
(performance.now() + performance.timing.navigationStart) : Date.now()) :
// Integer milliseconds since unix epoch
timestamp || new Date().getTime());
if (drawStart - animationStartTime >= 1000) {
plugin._updateTargets();
animationStartTime = drawStart;
}
requestAnimationFrame(timerCallBack);
}
var requestAnimationFrame = window.requestAnimationFrame ||
window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame ||
window.oRequestAnimationFrame || window.msRequestAnimationFrame || null;
// This is when we expect a fall-back to setInterval as it's much more fluid
var animationStartTime = 0;
if (!requestAnimationFrame || $.noRequestAnimationFrame) {
$.noRequestAnimationFrame = null;
setInterval(function() { plugin._updateTargets(); }, 980); // Fall back to good old setInterval
}
else {
animationStartTime = window.animationStartTime ||
window.webkitAnimationStartTime || window.mozAnimationStartTime ||
window.oAnimationStartTime || window.msAnimationStartTime || new Date().getTime();
requestAnimationFrame(timerCallBack);
}
}

var Y = 0; // Years
var O = 1; // Months
var W = 2; // Weeks
var D = 3; // Days
var H = 4; // Hours
var M = 5; // Minutes
var S = 6; // Seconds

$.extend(Countdown.prototype, {
/* Class name added to elements to indicate already configured with countdown. */
markerClassName: 'hasCountdown',
/* Name of the data property for instance settings. */
propertyName: 'countdown',

/* Class name for the right-to-left marker. */
_rtlClass: 'countdown_rtl',
/* Class name for the countdown section marker. */
_sectionClass: 'countdown_section',
/* Class name for the period amount marker. */
_amountClass: 'countdown_amount',
/* Class name for the countdown row marker. */
_rowClass: 'countdown_row',
/* Class name for the holding countdown marker. */
_holdingClass: 'countdown_holding',
/* Class name for the showing countdown marker. */
_showClass: 'countdown_show',
/* Class name for the description marker. */
_descrClass: 'countdown_descr',

/* List of currently active countdown targets. */
_timerTargets: [],

/* Override the default settings for all instances of the countdown widget.
@param options (object) the new settings to use as defaults */
setDefaults: function(options) {
this._resetExtraLabels(this._defaults, options);
$.extend(this._defaults, options || {});
},

/* Convert a date/time to UTC.
@param tz (number) the hour or minute offset from GMT, e.g. +9, -360
@param year (Date) the date/time in that timezone or
(number) the year in that timezone
@param month (number, optional) the month (0 - 11) (omit if year is a Date)
@param day (number, optional) the day (omit if year is a Date)
@param hours (number, optional) the hour (omit if year is a Date)
@param mins (number, optional) the minute (omit if year is a Date)
@param secs (number, optional) the second (omit if year is a Date)
@param ms (number, optional) the millisecond (omit if year is a Date)
@return (Date) the equivalent UTC date/time */
UTCDate: function(tz, year, month, day, hours, mins, secs, ms) {
if (typeof year == 'object' && year.constructor == Date) {
ms = year.getMilliseconds();
secs = year.getSeconds();
mins = year.getMinutes();
hours = year.getHours();
day = year.getDate();
month = year.getMonth();
year = year.getFullYear();
}
var d = new Date();
d.setUTCFullYear(year);
d.setUTCDate(1);
d.setUTCMonth(month || 0);
d.setUTCDate(day || 1);
d.setUTCHours(hours || 0);
d.setUTCMinutes((mins || 0) - (Math.abs(tz) < 30 ? tz * 60 : tz));
d.setUTCSeconds(secs || 0);
d.setUTCMilliseconds(ms || 0);
return d;
},

/* Convert a set of periods into seconds.
Averaged for months and years.
@param periods (number[7]) the periods per year/month/week/day/hour/minute/second
@return (number) the corresponding number of seconds */
periodsToSeconds: function(periods) {
return periods[0] * 31557600 + periods[1] * 2629800 + periods[2] * 604800 +
periods[3] * 86400 + periods[4] * 3600 + periods[5] * 60 + periods[6];
},

/* Attach the countdown widget to a div.
@param target (element) the containing division
@param options (object) the initial settings for the countdown */
_attachPlugin: function(target, options) {
target = $(target);
if (target.hasClass(this.markerClassName)) {
return;
}
var inst = {options: $.extend({}, this._defaults), _periods: [0, 0, 0, 0, 0, 0, 0]};
target.addClass(this.markerClassName).data(this.pr opertyName, inst);
this._optionPlugin(target, options);
},

/* Add a target to the list of active ones.
@param target (element) the countdown target */
_addTarget: function(target) {
if (!this._hasTarget(target)) {
this._timerTargets.push(target);
}
},

/* See if a target is in the list of active ones.
@param target (element) the countdown target
@return (boolean) true if present, false if not */
_hasTarget: function(target) {
return ($.inArray(target, this._timerTargets) > -1);
},

/* Remove a target from the list of active ones.
@param target (element) the countdown target */
_removeTarget: function(target) {
this._timerTargets = $.map(this._timerTargets,
function(value) { return (value == target ? null : value); }); // delete entry
},

/* Update each active timer target. */
_updateTargets: function() {
for (var i = this._timerTargets.length - 1; i >= 0; i--) {
this._updateCountdown(this._timerTargets[i]);
}
},

/* Reconfigure the settings for a countdown div.
@param target (element) the control to affect
@param options (object) the new options for this instance or
(string) an individual property name
@param value (any) the individual property value (omit if options
is an object or to retrieve the value of a setting)
@return (any) if retrieving a value */
_optionPlugin: function(target, options, value) {
target = $(target);
var inst = target.data(this.propertyName);
if (!options || (typeof options == 'string' && value == null)) { // Get option
var name = options;
options = (inst || {}).options;
return (options && name ? options[name] : options);
}

if (!target.hasClass(this.markerClassName)) {
return;
}
options = options || {};
if (typeof options == 'string') {
var name = options;
options = {};
options[name] = value;
}
this._resetExtraLabels(inst.options, options);
var timezoneChanged = (inst.options.timezone != options.timezone);
$.extend(inst.options, options);
this._adjustSettings(target, inst,
options.until != null || options.since != null || timezoneChanged);
var now = new Date();
if ((inst._since && inst._since < now) || (inst._until && inst._until > now)) {
this._addTarget(target[0]);
}
this._updateCountdown(target, inst);
},

/* Redisplay the countdown with an updated display.
@param target (jQuery) the containing division
@param inst (object) the current settings for this instance */
_updateCountdown: function(target, inst) {
var $target = $(target);
inst = inst || $target.data(this.propertyName);
if (!inst) {
return;
}
$target.html(this._generateHTML(inst)).toggleClass (this._rtlClass, inst.options.isRTL);
if ($.isFunction(inst.options.onTick)) {
var periods = inst._hold != 'lap' ? inst._periods :
this._calculatePeriods(inst, inst._show, inst.options.significant, new Date());
if (inst.options.tickInterval == 1 ||
this.periodsToSeconds(periods) % inst.options.tickInterval == 0) {
inst.options.onTick.apply(target, [periods]);
}
}
var expired = inst._hold != 'pause' &&
(inst._since ? inst._now.getTime() < inst._since.getTime() :
inst._now.getTime() >= inst._until.getTime());
if (expired && !inst._expiring) {
inst._expiring = true;
if (this._hasTarget(target) || inst.options.alwaysExpire) {
this._removeTarget(target);
if ($.isFunction(inst.options.onExpiry)) {
inst.options.onExpiry.apply(target, []);
}
if (inst.options.expiryText) {
var layout = inst.options.layout;
inst.options.layout = inst.options.expiryText;
this._updateCountdown(target, inst);
inst.options.layout = layout;
}
if (inst.options.expiryUrl) {
window.location = inst.options.expiryUrl;
}
}
inst._expiring = false;
}
else if (inst._hold == 'pause') {
this._removeTarget(target);
}
$target.data(this.propertyName, inst);
},

/* Reset any extra labelsn and compactLabelsn entries if changing labels.
@param base (object) the options to be updated
@param options (object) the new option values */
_resetExtraLabels: function(base, options) {
var changingLabels = false;
for (var n in options) {
if (n != 'whichLabels' && n.match(/[Ll]abels/)) {
changingLabels = true;
break;
}
}
if (changingLabels) {
for (var n in base) { // Remove custom numbered labels
if (n.match(/[Ll]abels[02-9]|compactLabels1/)) {
base[n] = null;
}
}
}
},

/* Calculate interal settings for an instance.
@param target (element) the containing division
@param inst (object) the current settings for this instance
@param recalc (boolean) true if until or since are set */
_adjustSettings: function(target, inst, recalc) {
var now;
var serverOffset = 0;
var serverEntry = null;
for (var i = 0; i < this._serverSyncs.length; i++) {
if (this._serverSyncs[i][0] == inst.options.serverSync) {
serverEntry = this._serverSyncs[i][1];
break;
}
}
if (serverEntry != null) {
serverOffset = (inst.options.serverSync ? serverEntry : 0);
now = new Date();
}
else {
var serverResult = ($.isFunction(inst.options.serverSync) ?
inst.options.serverSync.apply(target, []) : null);
now = new Date();
serverOffset = (serverResult ? now.getTime() - serverResult.getTime() : 0);
this._serverSyncs.push([inst.options.serverSync, serverOffset]);
}
var timezone = inst.options.timezone;
timezone = (timezone == null ? -now.getTimezoneOffset() : timezone);
if (recalc || (!recalc && inst._until == null && inst._since == null)) {
inst._since = inst.options.since;
if (inst._since != null) {
inst._since = this.UTCDate(timezone, this._determineTime(inst._since, null));
if (inst._since && serverOffset) {
inst._since.setMilliseconds(inst._since.getMillise conds() + serverOffset);
}
}
inst._until = this.UTCDate(timezone, this._determineTime(inst.options.until, now));
if (serverOffset) {
inst._until.setMilliseconds(inst._until.getMillise conds() + serverOffset);
}
}
inst._show = this._determineShow(inst);
},

/* Remove the countdown widget from a div.
@param target (element) the containing division */
_destroyPlugin: function(target) {
target = $(target);
if (!target.hasClass(this.markerClassName)) {
return;
}
this._removeTarget(target[0]);
target.removeClass(this.markerClassName).empty().r emoveData(this.propertyName);
},

/* Pause a countdown widget at the current time.
Stop it running but remember and display the current time.
@param target (element) the containing division */
_pausePlugin: function(target) {
this._hold(target, 'pause');
},

/* Pause a countdown widget at the current time.
Stop the display but keep the countdown running.
@param target (element) the containing division */
_lapPlugin: function(target) {
this._hold(target, 'lap');
},

/* Resume a paused countdown widget.
@param target (element) the containing division */
_resumePlugin: function(target) {
this._hold(target, null);
},

/* Pause or resume a countdown widget.
@param target (element) the containing division
@param hold (string) the new hold setting */
_hold: function(target, hold) {
var inst = $.data(target, this.propertyName);
if (inst) {
if (inst._hold == 'pause' && !hold) {
inst._periods = inst._savePeriods;
var sign = (inst._since ? '-' : '+');
inst[inst._since ? '_since' : '_until'] =
this._determineTime(sign + inst._periods[0] + 'y' +
sign + inst._periods[1] + 'o' + sign + inst._periods[2] + 'w' +
sign + inst._periods[3] + 'd' + sign + inst._periods[4] + 'h' +
sign + inst._periods[5] + 'm' + sign + inst._periods[6] + 's');
this._addTarget(target);
}
inst._hold = hold;
inst._savePeriods = (hold == 'pause' ? inst._periods : null);
$.data(target, this.propertyName, inst);
this._updateCountdown(target, inst);
}
},

/* Return the current time periods.
@param target (element) the containing division
@return (number[7]) the current periods for the countdown */
_getTimesPlugin: function(target) {