/*
Base.js, version 1.1a
Copyright 2006-2010, Dean Edwards
License: http://www.opensource.org/licenses/mit-license.php
*/
var Base = function () {
// dummy
};
Base.extend = function (_instance, _static) { // subclass
"use strict";
var extend = Base.prototype.extend;
// build the prototype
Base._prototyping = true;
var proto = new this();
extend.call(proto, _instance);
proto.base = function () {
// call this method from any other method to invoke that method's ancestor
};
delete Base._prototyping;
// create the wrapper for the constructor function
//var constructor = proto.constructor.valueOf(); //-dean
var constructor = proto.constructor;
var klass = proto.constructor = function () {
if (!Base._prototyping) {
if (this._constructing || this.constructor == klass) { // instantiation
this._constructing = true;
constructor.apply(this, arguments);
delete this._constructing;
} else if (arguments[0] !== null) { // casting
return (arguments[0].extend || extend).call(arguments[0], proto);
}
}
};
// build the class interface
klass.ancestor = this;
klass.extend = this.extend;
klass.forEach = this.forEach;
klass.implement = this.implement;
klass.prototype = proto;
klass.toString = this.toString;
klass.valueOf = function (type) {
//return (type == "object") ? klass : constructor; //-dean
return (type == "object") ? klass : constructor.valueOf();
};
extend.call(klass, _static);
// class initialisation
if (typeof klass.init == "function")
klass.init();
return klass;
};
Base.prototype = {
extend: function (source, value) {
if (arguments.length > 1) { // extending with a name/value pair
var ancestor = this[source];
if (ancestor && (typeof value == "function") && // overriding a method?
// the valueOf() comparison is to avoid circular references
(!ancestor.valueOf || ancestor.valueOf() != value.valueOf()) &&
/\bbase\b/.test(value)) {
// get the underlying method
var method = value.valueOf();
// override
value = function () {
var previous = this.base || Base.prototype.base;
this.base = ancestor;
var returnValue = method.apply(this, arguments);
this.base = previous;
return returnValue;
};
// point to the underlying method
value.valueOf = function (type) {
return (type == "object") ? value : method;
};
value.toString = Base.toString;
}
this[source] = value;
} else if (source) { // extending with an object literal
var extend = Base.prototype.extend;
// if this object has a customised extend method then use it
if (!Base._prototyping && typeof this != "function") {
extend = this.extend || extend;
}
var proto = {toSource: null};
// do the "toString" and other methods manually
var hidden = ["constructor", "toString", "valueOf"];
// if we are prototyping then include the constructor
var i = Base._prototyping ? 0 : 1;
while (key = hidden[i++]) {
if (source[key] != proto[key]) {
extend.call(this, key, source[key]);
}
}
// copy each of the source object's properties to this object
for (var key in source) {
if (!proto[key])
extend.call(this, key, source[key]);
}
}
return this;
}
};
// initialise
Base = Base.extend({
constructor: function () {
this.extend(arguments[0]);
}
}, {
ancestor: Object,
version: "1.1",
forEach: function (object, block, context) {
for (var key in object) {
if (this.prototype[key] === undefined) {
block.call(context, object[key], key, object);
}
}
},
implement: function () {
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] == "function") {
// if it's a function, call it
arguments[i](this.prototype);
} else {
// add the interface using the extend method
this.prototype.extend(arguments[i]);
}
}
return this;
},
toString: function () {
return String(this.valueOf());
}
});
/*jshint smarttabs:true */
var FlipClock;
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* FlipFlock Helper
*
* @param object A jQuery object or CSS select
* @param int An integer used to start the clock (no. seconds)
* @param object An object of properties to override the default
*/
FlipClock = function (obj, digit, options) {
if (typeof digit == "object") {
options = digit;
digit = 0;
}
return new FlipClock.Factory(obj, digit, options);
};
/**
* The global FlipClock.Lang object
*/
FlipClock.Lang = {};
/**
* The Base FlipClock class is used to extend all other FlipFlock
* classes. It handles the callbacks and the basic setters/getters
*
* @param object An object of the default properties
* @param object An object of properties to override the default
*/
FlipClock.Base = Base.extend({
/**
* Build Date
*/
buildDate: '2014-06-03',
/**
* Version
*/
version: '0.5.5',
/**
* Sets the default options
*
* @param object The default options
* @param object The override options
*/
constructor: function (_default, options) {
if (typeof _default !== "object") {
_default = {};
}
if (typeof options !== "object") {
options = {};
}
this.setOptions($.extend(true, {}, _default, options));
},
/**
* Delegates the callback to the defined method
*
* @param object The default options
* @param object The override options
*/
callback: function (method) {
if (typeof method === "function") {
var args = [];
for (var x = 1; x <= arguments.length; x++) {
if (arguments[x]) {
args.push(arguments[x]);
}
}
method.apply(this, args);
}
},
/**
* Log a string into the console if it exists
*
* @param string The name of the option
* @return mixed
*/
log: function (str) {
if (window.console && console.log) {
console.log(str);
}
},
/**
* Get an single option value. Returns false if option does not exist
*
* @param string The name of the option
* @return mixed
*/
getOption: function (index) {
if (this[index]) {
return this[index];
}
return false;
},
/**
* Get all options
*
* @return bool
*/
getOptions: function () {
return this;
},
/**
* Set a single option value
*
* @param string The name of the option
* @param mixed The value of the option
*/
setOption: function (index, value) {
this[index] = value;
},
/**
* Set a multiple options by passing a JSON object
*
* @param object The object with the options
* @param mixed The value of the option
*/
setOptions: function (options) {
for (var key in options) {
if (typeof options[key] !== "undefined") {
this.setOption(key, options[key]);
}
}
}
});
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* The FlipClock Face class is the base class in which to extend
* all other FlockClock.Face classes.
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.Face = FlipClock.Base.extend({
/**
* An array of jQuery objects used for the dividers (the colons)
*/
dividers: [],
/**
* An array of FlipClock.List objects
*/
factory: false,
/**
* An array of FlipClock.List objects
*/
lists: [],
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
this.base(options);
this.factory = factory;
this.dividers = [];
},
/**
* Build the clock face
*/
build: function () {
},
/**
* Creates a jQuery object used for the digit divider
*
* @param mixed The divider label text
* @param mixed Set true to exclude the dots in the divider.
* If not set, is false.
*/
createDivider: function (label, css, excludeDots) {
if (typeof css == "boolean" || !css) {
excludeDots = css;
css = label;
}
var dots = [
'',
''
].join('');
if (excludeDots) {
dots = '';
}
label = this.factory.localize(label);
var html = [
'',
'' + (label ? label : '') + '',
dots,
''
];
return $(html.join(''));
},
/**
* Creates a FlipClock.List object and appends it to the DOM
*
* @param mixed The digit to select in the list
* @param object An object to override the default properties
*/
createList: function (digit, options) {
if (typeof digit === "object") {
options = digit;
digit = 0;
}
var obj = new FlipClock.List(this.factory, digit, options);
//this.factory.$wrapper.append(obj.$obj);
return obj;
},
/**
* Triggers when the clock is reset
*/
reset: function () {
this.factory.time = new FlipClock.Time(
this.factor,
this.factory.original ? Math.round(this.factory.original) : 0
);
this.flip(this.factory.original, false);
},
/**
* Sets the clock time (deprecated, duplicate method)
*
setTime: function(time) {
this.flip();
},
*/
/**
* Sets the clock time
*/
addDigit: function (digit) {
var obj = this.createList(digit, {
classes: {
active: this.factory.classes.active,
before: this.factory.classes.before,
flip: this.factory.classes.flip
}
});
obj.$obj.insertBefore(this.factory.lists[0].$obj);
this.factory.lists.unshift(obj);
},
/**
* Triggers when the clock is started
*/
start: function () {
},
/**
* Triggers when the time on the clock stops
*/
stop: function () {
},
/**
* Increments the time with each face flip
*/
increment: function () {
if (!(this.factory.time.time instanceof Date)) {
if (!this.factory.countdown) {
this.factory.time.addSecond();
}
else {
if (this.factory.time.getTimeSeconds() == 0) {
this.factory.stop()
}
else {
this.factory.time.subSecond();
}
}
}
},
/**
* Triggers when the numbers on the clock flip
*/
flip: function (time, doNotAddPlayClass) {
var t = this;
this.increment();
var offset = t.factory.lists.length - time.length;
if (offset < 0) {
offset = 0;
}
$.each(time, function (i, digit) {
i += offset;
var list = t.factory.lists[i];
if (list) {
list.select(digit);
if (!doNotAddPlayClass) {
list.play();
}
}
else {
t.addDigit(digit);
}
});
for (var x = 0; x < time.length; x++) {
if (x >= offset && t.factory.lists[x].digit != time[x]) {
t.factory.lists[x].select(time[x]);
}
}
}
});
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* The FlipClock Factory class is used to build the clock and manage
* all the public methods.
*
* @param object A jQuery object or CSS selector used to fetch
the wrapping DOM nodes
* @param mixed This is the digit used to set the clock. If an
object is passed, 0 will be used.
* @param object An object of properties to override the default
*/
FlipClock.Factory = FlipClock.Base.extend({
/**
* Auto start the clock on page load (True|False)
*/
autoStart: true,
/**
* The callback methods
*/
callbacks: {
destroy: false,
create: false,
init: false,
interval: false,
start: false,
stop: false,
reset: false
},
/**
* The CSS classes
*/
classes: {
active: 'flip-clock-active',
before: 'flip-clock-before',
divider: 'flip-clock-divider',
dot: 'flip-clock-dot',
label: 'flip-clock-label',
flip: 'flip',
play: 'play',
wrapper: 'flip-clock-wrapper'
},
/**
* The name of the clock face class in use
*/
clockFace: 'HourlyCounter',
/**
* The name of the default clock face class to use if the defined
* clockFace variable is not a valid FlipClock.Face object
*/
defaultClockFace: 'HourlyCounter',
/**
* The default language
*/
defaultLanguage: 'english',
/**
* The language being used to display labels (string)
*/
language: 'english',
/**
* The language object after it has been loaded
*/
lang: false,
/**
* The original starting value of the clock. Used for the reset method.
*/
original: false,
/**
* The FlipClock.Face object
*/
face: true,
/**
* Is the clock running? (True|False)
*/
running: false,
/**
* The FlipClock.Time object
*/
time: false,
/**
* The FlipClock.Timer object
*/
timer: false,
/**
* An array of FlipClock.List objects
*/
lists: [],
/**
* The wrapping jQuery object
*/
$wrapper: false,
/**
* Constructor
*
* @param object The wrapping jQuery object
* @param object Number of seconds used to start the clock
* @param object An object override options
*/
constructor: function (obj, digit, options) {
if (!options) {
options = {};
}
this.lists = [];
this.running = false;
this.base(options);
this.$wrapper = $(obj).addClass(this.classes.wrapper);
this.original = (digit instanceof Date) ? digit : (digit ? Math.round(digit) : 0);
this.time = new FlipClock.Time(this, this.original, {
minimumDigits: options.minimumDigits ? options.minimumDigits : 0,
animationRate: options.animationRate ? options.animationRate : 1000
});
this.timer = new FlipClock.Timer(this, options);
this.lang = this.loadLanguage(this.language);
this.face = this.loadClockFace(this.clockFace, options);
if (this.autoStart) {
this.start();
}
},
/**
* Load the FlipClock.Face object
*
* @param object The name of the FlickClock.Face class
* @param object An object override options
*/
loadClockFace: function (name, options) {
var face, suffix = 'Face';
name = name.ucfirst() + suffix;
if (FlipClock[name]) {
face = new FlipClock[name](this, options);
}
else {
face = new FlipClock[this.defaultClockFace + suffix](this, options);
}
face.build();
return face;
},
/**
* Load the FlipClock.Lang object
*
* @param object The name of the language to load
*/
loadLanguage: function (name) {
var lang;
if (FlipClock.Lang[name.ucfirst()]) {
lang = FlipClock.Lang[name.ucfirst()];
}
else if (FlipClock.Lang[name]) {
lang = FlipClock.Lang[name];
}
else {
lang = FlipClock.Lang[this.defaultLanguage];
}
return lang;
},
/**
* Localize strings into various languages
*
* @param string The index of the localized string
* @param object Optionally pass a lang object
*/
localize: function (index, obj) {
var lang = this.lang;
if (!index) {
return null;
}
var lindex = index.toLowerCase();
if (typeof obj == "object") {
lang = obj;
}
if (lang && lang[lindex]) {
return lang[lindex];
}
return index;
},
/**
* Starts the clock
*/
start: function (callback) {
var t = this;
if (!t.running && (!t.countdown || t.countdown && t.time.time >= 0)) {
t.face.start(t.time);
t.timer.start(function () {
t.flip();
if (typeof callback === "function") {
callback();
}
});
}
else {
t.log('Trying to start timer when countdown already at 0');
}
},
/**
* Stops the clock
*/
stop: function (callback) {
this.face.stop();
this.timer.stop(callback);
for (var x in this.lists) {
this.lists[x].stop();
}
},
/**
* Reset the clock
*/
reset: function (callback) {
this.timer.reset(callback);
this.face.reset();
},
/**
* Sets the clock time
*/
setTime: function (time) {
this.time.time = time;
this.flip(true);
},
/**
* Get the clock time
*
* @return object Returns a FlipClock.Time object
*/
getTime: function (time) {
return this.time;
},
/**
* Changes the increment of time to up or down (add/sub)
*/
setCountdown: function (value) {
var running = this.running;
this.countdown = value ? true : false;
if (running) {
this.stop();
this.start();
}
},
/**
* Flip the digits on the clock
*
* @param array An array of digits
*/
flip: function (doNotAddPlayClass) {
this.face.flip(false, doNotAddPlayClass);
}
});
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* The FlipClock List class is used to build the list used to create
* the card flip effect. This object fascilates selecting the correct
* node by passing a specific digit.
*
* @param object A FlipClock.Factory object
* @param mixed This is the digit used to set the clock. If an
* object is passed, 0 will be used.
* @param object An object of properties to override the default
*/
FlipClock.List = FlipClock.Base.extend({
/**
* The digit (0-9)
*/
digit: 0,
/**
* The CSS classes
*/
classes: {
active: 'flip-clock-active',
before: 'flip-clock-before',
flip: 'flip'
},
/**
* The parent FlipClock.Factory object
*/
factory: false,
/**
* The wrapping jQuery object
*/
$obj: false,
/**
* The items in the list
*/
items: [],
/**
* Constructor
*
* @param object A FlipClock.Factory object
* @param int An integer use to select the correct digit
* @param object An object to override the default properties
*/
minimumDigits: 0,
constructor: function (factory, digit, options) {
this.factory = factory;
this.digit = digit;
this.$obj = this.createList();
if (digit > 0) {
this.select(digit);
}
this.factory.$wrapper.append(this.$obj);
},
/**
* Select the digit in the list
*
* @param int A digit 0-9
*/
select: function (digit) {
if (typeof digit === "undefined") {
digit = this.digit;
}
else {
this.digit = digit;
}
var target = this.$obj.find('[data-digit="' + digit + '"]');
var active = this.$obj.find('.' + this.classes.active).removeClass(this.classes.active);
var before = this.$obj.find('.' + this.classes.before).removeClass(this.classes.before);
if (!this.factory.countdown) {
if (target.is(':first-child')) {
this.$obj.find(':last-child').addClass(this.classes.before);
}
else {
target.prev().addClass(this.classes.before);
}
}
else {
if (target.is(':last-child')) {
this.$obj.find(':first-child').addClass(this.classes.before);
}
else {
target.next().addClass(this.classes.before);
}
}
target.addClass(this.classes.active);
},
/**
* Adds the play class to the DOM object
*/
play: function () {
this.$obj.addClass(this.factory.classes.play);
},
/**
* Removes the play class to the DOM object
*/
stop: function () {
var t = this;
setTimeout(function () {
t.$obj.removeClass(t.factory.classes.play);
}, this.factory.timer.interval);
},
/**
* Create the list of digits and appends it to the DOM object
*/
createList: function () {
var html = $('');
for (var x = 0; x < 10; x++) {
var item = $([
'',
'',
'',
'',
'',
''].join(''));
this.items.push(item);
html.append(item);
}
return html;
}
});
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* Capitalize the first letter in a string
*
* @return string
*/
String.prototype.ucfirst = function () {
return this.substr(0, 1).toUpperCase() + this.substr(1);
};
/**
* jQuery helper method
*
* @param int An integer used to start the clock (no. seconds)
* @param object An object of properties to override the default
*/
$.fn.FlipClock = function (digit, options) {
if (typeof digit == "object") {
options = digit;
digit = 0;
}
return new FlipClock($(this), digit, options);
};
/**
* jQuery helper method
*
* @param int An integer used to start the clock (no. seconds)
* @param object An object of properties to override the default
*/
$.fn.flipClock = function (digit, options) {
return $.fn.FlipClock(digit, options);
};
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* The FlipClock Time class is used to manage all the time
* calculations.
*
* @param object A FlipClock.Factory object
* @param mixed This is the digit used to set the clock. If an
* object is passed, 0 will be used.
* @param object An object of properties to override the default
*/
FlipClock.Time = FlipClock.Base.extend({
/**
* The time (in seconds)
*/
time: 0,
/**
* The parent FlipClock.Factory object
*/
factory: false,
/**
* The minimum number of digits the clock face will have
*/
minimumDigits: 0,
/**
* Constructor
*
* @param object A FlipClock.Factory object
* @param int An integer use to select the correct digit
* @param object An object to override the default properties
*/
constructor: function (factory, time, options) {
this.base(options);
this.factory = factory;
if (time) {
this.time = time;
}
},
/**
* Convert a string or integer to an array of digits
*
* @param mixed String or Integer of digits
* @return array An array of digits
*/
convertDigitsToArray: function (str) {
var data = [];
str = str.toString();
for (var x = 0; x < str.length; x++) {
if (str[x].match(/^\d*$/g)) {
data.push(str[x]);
}
}
return data;
},
/**
* Get a specific digit from the time integer
*
* @param int The specific digit to select from the time
* @return mixed Returns FALSE if no digit is found, otherwise
* the method returns the defined digit
*/
digit: function (i) {
var timeStr = this.toString();
var length = timeStr.length;
if (timeStr[length - i]) {
return timeStr[length - i];
}
return false;
},
/**
* Formats any array of digits into a valid array of digits
*
* @param mixed An array of digits
* @return array An array of digits
*/
digitize: function (obj) {
var data = [];
$.each(obj, function (i, value) {
value = value.toString();
if (value.length == 1) {
value = '0' + value;
}
for (var x = 0; x < value.length; x++) {
data.push(value.charAt(x));
}
});
if (data.length > this.minimumDigits) {
this.minimumDigits = data.length;
}
if (this.minimumDigits > data.length) {
for (var x = data.length; x < this.minimumDigits; x++) {
data.unshift('0');
}
}
return data;
},
/**
* Gets a daily breakdown
*
* @return object Returns a digitized object
*/
getDayCounter: function (includeSeconds) {
var digits = [
this.getDays(),
this.getHours(true),
this.getMinutes(true)
];
if (includeSeconds) {
digits.push(this.getSeconds(true));
}
return this.digitize(digits);
},
/**
* Gets number of days
*
* @param bool Should perform a modulus? If not sent, then no.
* @return int Retuns a floored integer
*/
getDays: function (mod) {
var days = this.getTimeSeconds() / 60 / 60 / 24;
if (mod) {
days = days % 7;
}
return Math.floor(days);
},
/**
* Gets an hourly breakdown
*
* @return object Returns a digitized object
*/
getHourCounter: function () {
var obj = this.digitize([
this.getHours(),
this.getMinutes(true),
this.getSeconds(true)
]);
return obj;
},
/**
* Gets an hourly breakdown
*
* @return object Returns a digitized object
*/
getHourly: function () {
return this.getHourCounter();
},
/**
* Gets number of hours
*
* @param bool Should perform a modulus? If not sent, then no.
* @return int Retuns a floored integer
*/
getHours: function (mod) {
var hours = this.getTimeSeconds() / 60 / 60;
if (mod) {
hours = hours % 24;
}
return Math.floor(hours);
},
/**
* Gets the twenty-four hour time
*
* @return object returns a digitized object
*/
getMilitaryTime: function () {
var date = new Date();
var obj = this.digitize([
date.getHours(),
date.getMinutes(),
date.getSeconds()
]);
return obj;
},
/**
* Gets number of minutes
*
* @param bool Should perform a modulus? If not sent, then no.
* @return int Retuns a floored integer
*/
getMinutes: function (mod) {
var minutes = this.getTimeSeconds() / 60;
if (mod) {
minutes = minutes % 60;
}
return Math.floor(minutes);
},
/**
* Gets a minute breakdown
*/
getMinuteCounter: function () {
var obj = this.digitize([
this.getMinutes(),
this.getSeconds(true)
]);
return obj;
},
/**
* Gets time count in seconds regardless of if targetting date or not.
*
* @return int Returns a floored integer
*/
getTimeSeconds: function (mod) {
if (this.time instanceof Date) {
if (this.factory.countdown) {
if ((new Date()).getTime() > this.time.getTime()) {
this.factory.stop();
}
return Math.max(this.time.getTime() / 1000 - (new Date()).getTime() / 1000, 0);
} else {
return (new Date()).getTime() / 1000 - this.time.getTime() / 1000;
}
} else {
return this.time;
}
},
/**
* Gets number of seconds
*
* @param bool Should perform a modulus? If not sent, then no.
* @return int Retuns a ceiled integer
*/
getSeconds: function (mod) {
var seconds = this.getTimeSeconds();
if (mod) {
if (seconds == 60) {
seconds = 0;
}
else {
seconds = seconds % 60;
}
}
return Math.ceil(seconds);
},
/**
* Gets the current twelve hour time
*
* @return object Returns a digitized object
*/
getTime: function () {
var date = new Date();
var hours = date.getHours();
var merid = hours > 12 ? 'PM' : 'AM';
var obj = this.digitize([
hours > 12 ? hours - 12 : (hours === 0 ? 12 : hours),
date.getMinutes(),
date.getSeconds()
]);
return obj;
},
/**
* Gets number of weeks
*
* @param bool Should perform a modulus? If not sent, then no.
* @return int Retuns a floored integer
*/
getWeeks: function () {
var weeks = this.getTimeSeconds() / 60 / 60 / 24 / 7;
if (mod) {
weeks = weeks % 52;
}
return Math.floor(weeks);
},
/**
* Removes a specific number of leading zeros from the array.
* This method prevents you from removing too many digits, even
* if you try.
*
* @param int Total number of digits to remove
* @return array An array of digits
*/
removeLeadingZeros: function (totalDigits, digits) {
var total = 0;
var newArray = [];
$.each(digits, function (i, digit) {
if (i < totalDigits) {
total += parseInt(digits[i], 10);
}
else {
newArray.push(digits[i]);
}
});
if (total === 0) {
return newArray;
}
return digits;
},
/**
* Adds X second to the current time
*/
addSeconds: function (x) {
this.time += x;
},
/**
* Adds 1 second to the current time
*/
addSecond: function () {
this.addSeconds(1);
},
/**
* Substracts X seconds from the current time
*/
subSeconds: function (x) {
this.time -= x;
},
/**
* Substracts 1 second from the current time
*/
subSecond: function () {
this.subSeconds(1);
},
/**
* Converts the object to a human readable string
*/
toString: function () {
return this.getTimeSeconds().toString();
}
/*
getYears: function() {
return Math.floor(this.time / 60 / 60 / 24 / 7 / 52);
},
getDecades: function() {
return Math.floor(this.getWeeks() / 10);
}*/
});
}(jQuery));
/*jshint smarttabs:true */
/**
* FlipClock.js
*
* @author Justin Kimbrell
* @copyright 2013 - Objective HTML, LLC
* @licesnse http://www.opensource.org/licenses/mit-license.php
*/
(function ($) {
"use strict";
/**
* The FlipClock.Timer object managers the JS timers
*
* @param object The parent FlipClock.Factory object
* @param object Override the default options
*/
FlipClock.Timer = FlipClock.Base.extend({
/**
* Callbacks
*/
callbacks: {
destroy: false,
create: false,
init: false,
interval: false,
start: false,
stop: false,
reset: false
},
/**
* FlipClock timer count (how many intervals have passed)
*/
count: 0,
/**
* The parent FlipClock.Factory object
*/
factory: false,
/**
* Timer interval (1 second by default)
*/
interval: 1000,
/**
* The rate of the animation in milliseconds
*/
animationRate: 1000,
/**
* Constructor
*
* @return void
*/
constructor: function (factory, options) {
this.base(options);
this.factory = factory;
this.callback(this.callbacks.init);
this.callback(this.callbacks.create);
},
/**
* This method gets the elapsed the time as an interger
*
* @return void
*/
getElapsed: function () {
return this.count * this.interval;
},
/**
* This method gets the elapsed the time as a Date object
*
* @return void
*/
getElapsedTime: function () {
return new Date(this.time + this.getElapsed());
},
/**
* This method is resets the timer
*
* @param callback This method resets the timer back to 0
* @return void
*/
reset: function (callback) {
clearInterval(this.timer);
this.count = 0;
this._setInterval(callback);
this.callback(this.callbacks.reset);
},
/**
* This method is starts the timer
*
* @param callback A function that is called once the timer is destroyed
* @return void
*/
start: function (callback) {
this.factory.running = true;
this._createTimer(callback);
this.callback(this.callbacks.start);
},
/**
* This method is stops the timer
*
* @param callback A function that is called once the timer is destroyed
* @return void
*/
stop: function (callback) {
this.factory.running = false;
this._clearInterval(callback);
this.callback(this.callbacks.stop);
this.callback(callback);
},
/**
* Clear the timer interval
*
* @return void
*/
_clearInterval: function () {
clearInterval(this.timer);
},
/**
* Create the timer object
*
* @param callback A function that is called once the timer is created
* @return void
*/
_createTimer: function (callback) {
this._setInterval(callback);
},
/**
* Destroy the timer object
*
* @param callback A function that is called once the timer is destroyed
* @return void
*/
_destroyTimer: function (callback) {
this._clearInterval();
this.timer = false;
this.callback(callback);
this.callback(this.callbacks.destroy);
},
/**
* This method is called each time the timer interval is ran
*
* @param callback A function that is called once the timer is destroyed
* @return void
*/
_interval: function (callback) {
this.callback(this.callbacks.interval);
this.callback(callback);
this.count++;
},
/**
* This sets the timer interval
*
* @param callback A function that is called once the timer is destroyed
* @return void
*/
_setInterval: function (callback) {
var t = this;
t._interval(callback);
t.timer = setInterval(function () {
t._interval(callback);
}, this.interval);
}
});
}(jQuery));
(function ($) {
/**
* Twenty-Four Hour Clock Face
*
* This class will generate a twenty-four our clock for FlipClock.js
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.TwentyFourHourClockFace = FlipClock.Face.extend({
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
factory.countdown = false;
this.base(factory, options);
},
/**
* Build the clock face
*
* @param object Pass the time that should be used to display on the clock.
*/
build: function (time) {
var t = this;
var children = this.factory.$wrapper.find('ul');
time = time ? time : (this.factory.time.time || this.factory.time.getMilitaryTime());
if (time.length > children.length) {
$.each(time, function (i, digit) {
t.factory.lists.push(t.createList(digit));
});
}
this.dividers.push(this.createDivider());
this.dividers.push(this.createDivider());
$(this.dividers[0]).insertBefore(this.factory.lists[this.factory.lists.length - 2].$obj);
$(this.dividers[1]).insertBefore(this.factory.lists[this.factory.lists.length - 4].$obj);
this._clearExcessDigits();
if (this.autoStart) {
this.start();
}
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
time = time ? time : this.factory.time.getMilitaryTime();
this.base(time, doNotAddPlayClass);
},
/**
* Clear the excess digits from the tens columns for sec/min
*/
_clearExcessDigits: function () {
var tenSeconds = this.factory.lists[this.factory.lists.length - 2];
var tenMinutes = this.factory.lists[this.factory.lists.length - 4];
for (var x = 6; x < 10; x++) {
tenSeconds.$obj.find('li:last-child').remove();
tenMinutes.$obj.find('li:last-child').remove();
}
}
});
}(jQuery));
(function ($) {
/**
* Counter Clock Face
*
* This class will generate a generice flip counter. The timer has been
* disabled. clock.increment() and clock.decrement() have been added.
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.CounterFace = FlipClock.Face.extend({
autoStart: false,
minimumDigits: 2,
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
factory.timer.interval = 0;
factory.autoStart = false;
factory.running = true;
factory.increment = function () {
factory.countdown = false;
factory.setTime(factory.getTime().getTimeSeconds() + 1);
};
factory.decrement = function () {
factory.countdown = true;
var time = factory.getTime().getTimeSeconds();
if (time > 0) {
factory.setTime(time - 1);
}
};
factory.setValue = function (digits) {
factory.setTime(digits);
};
factory.setCounter = function (digits) {
factory.setTime(digits);
};
this.base(factory, options);
},
/**
* Increments the time with each face flip
*/
increment: function () {
},
/**
* Build the clock face
*/
build: function () {
var t = this;
var children = this.factory.$wrapper.find('ul');
var lists = [];
var time = this.factory.getTime().digitize([this.factory.getTime().time]);
if (time.length > children.length) {
$.each(time, function (i, digit) {
var list = t.createList(digit, {
minimumDigits: t.minimumDigits,
});
list.select(digit);
lists.push(list);
});
}
$.each(lists, function (i, list) {
list.play();
});
this.factory.lists = lists;
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
if (!time) {
time = this.factory.getTime().digitize([this.factory.getTime().time]);
}
this.base(time, doNotAddPlayClass);
},
/**
* Reset the clock face
*/
reset: function () {
this.factory.time = new FlipClock.Time(
this.factor,
this.factory.original ? Math.round(this.factory.original) : 0
);
this.flip();
}
});
}(jQuery));
(function ($) {
/**
* Daily Counter Clock Face
*
* This class will generate a daily counter for FlipClock.js. A
* daily counter will track days, hours, minutes, and seconds. If
* the number of available digits is exceeded in the count, a new
* digit will be created.
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.DailyCounterFace = FlipClock.Face.extend({
showSeconds: true,
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
this.base(factory, options);
},
/**
* Build the clock face
*/
build: function (excludeHours, time) {
var t = this;
var children = this.factory.$wrapper.find('ul');
var lists = [];
var offset = 0;
time = time ? time : this.factory.time.getDayCounter(this.showSeconds);
if (time.length > children.length) {
$.each(time, function (i, digit) {
lists.push(t.createList(digit));
});
}
this.factory.lists = lists;
if (this.showSeconds) {
$(this.createDivider('Seconds')).insertBefore(this.factory.lists[this.factory.lists.length - 2].$obj);
}
else
{
offset = 2;
}
$(this.createDivider('Minutes')).insertBefore(this.factory.lists[this.factory.lists.length - 4 + offset].$obj);
$(this.createDivider('Hours')).insertBefore(this.factory.lists[this.factory.lists.length - 6 + offset].$obj);
$(this.createDivider('Days', true)).insertBefore(this.factory.lists[0].$obj);
this._clearExcessDigits();
if (this.autoStart) {
this.start();
}
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
if (!time) {
time = this.factory.time.getDayCounter(this.showSeconds);
}
this.base(time, doNotAddPlayClass);
},
/**
* Clear the excess digits from the tens columns for sec/min
*/
_clearExcessDigits: function () {
var tenSeconds = this.factory.lists[this.factory.lists.length - 2];
var tenMinutes = this.factory.lists[this.factory.lists.length - 4];
for (var x = 6; x < 10; x++) {
tenSeconds.$obj.find('li:last-child').remove();
tenMinutes.$obj.find('li:last-child').remove();
}
}
});
}(jQuery));
(function ($) {
/**
* Hourly Counter Clock Face
*
* This class will generate an hourly counter for FlipClock.js. An
* hour counter will track hours, minutes, and seconds. If number of
* available digits is exceeded in the count, a new digit will be
* created.
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.HourlyCounterFace = FlipClock.Face.extend({
clearExcessDigits: true,
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
this.base(factory, options);
},
/**
* Build the clock face
*/
build: function (excludeHours, time) {
var t = this;
var children = this.factory.$wrapper.find('ul');
var lists = [];
time = time ? time : this.factory.time.getHourCounter();
if (time.length > children.length) {
$.each(time, function (i, digit) {
lists.push(t.createList(digit));
});
}
this.factory.lists = lists;
$(this.createDivider('Seconds')).insertBefore(this.factory.lists[this.factory.lists.length - 2].$obj);
$(this.createDivider('Minutes')).insertBefore(this.factory.lists[this.factory.lists.length - 4].$obj);
if (!excludeHours) {
$(this.createDivider('Hours', true)).insertBefore(this.factory.lists[0].$obj);
}
if (this.clearExcessDigits) {
this._clearExcessDigits();
}
if (this.autoStart) {
this.start();
}
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
if (!time) {
time = this.factory.time.getHourCounter();
}
this.base(time, doNotAddPlayClass);
},
/**
* Clear the excess digits from the tens columns for sec/min
*/
_clearExcessDigits: function () {
var tenSeconds = this.factory.lists[this.factory.lists.length - 2];
var tenMinutes = this.factory.lists[this.factory.lists.length - 4];
for (var x = 6; x < 10; x++) {
tenSeconds.$obj.find('li:last-child').remove();
tenMinutes.$obj.find('li:last-child').remove();
}
}
});
}(jQuery));
(function ($) {
/**
* Minute Counter Clock Face
*
* This class will generate a minute counter for FlipClock.js. A
* minute counter will track minutes and seconds. If an hour is
* reached, the counter will reset back to 0. (4 digits max)
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.MinuteCounterFace = FlipClock.HourlyCounterFace.extend({
clearExcessDigits: false,
/**
* Constructor
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
constructor: function (factory, options) {
this.base(factory, options);
},
/**
* Build the clock face
*/
build: function () {
this.base(true, this.factory.time.getMinuteCounter());
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
if (!time) {
time = this.factory.time.getMinuteCounter();
}
this.base(time, doNotAddPlayClass);
},
});
}(jQuery));
(function ($) {
/**
* Twelve Hour Clock Face
*
* This class will generate a twelve hour clock for FlipClock.js
*
* @param object The parent FlipClock.Factory object
* @param object An object of properties to override the default
*/
FlipClock.TwelveHourClockFace = FlipClock.TwentyFourHourClockFace.extend({
/**
* The meridium jQuery DOM object
*/
meridium: false,
/**
* The meridium text as string for easy access
*/
meridiumText: 'AM',
/**
* Build the clock face
*
* @param object Pass the time that should be used to display on the clock.
*/
build: function (time) {
var t = this;
time = time ? time : (this.factory.time.time ? this.factory.time.time : this.factory.time.getTime());
this.base(time);
this.meridiumText = this._isPM() ? 'PM' : 'AM';
this.meridium = $([
''
].join(''));
this.meridium.insertAfter(this.factory.lists[this.factory.lists.length - 1].$obj);
},
/**
* Flip the clock face
*/
flip: function (time, doNotAddPlayClass) {
if (this.meridiumText != this._getMeridium()) {
this.meridiumText = this._getMeridium();
this.meridium.find('a').html(this.meridiumText);
}
this.base(this.factory.time.getTime(), doNotAddPlayClass);
},
/**
* Get the current meridium
*
* @return string Returns the meridium (AM|PM)
*/
_getMeridium: function () {
return new Date().getHours() >= 12 ? 'PM' : 'AM';
},
/**
* Is it currently in the post-medirium?
*
* @return bool Returns true or false
*/
_isPM: function () {
return this._getMeridium() == 'PM' ? true : false;
},
/**
* Clear the excess digits from the tens columns for sec/min
*/
_clearExcessDigits: function () {
var tenSeconds = this.factory.lists[this.factory.lists.length - 2];
var tenMinutes = this.factory.lists[this.factory.lists.length - 4];
for (var x = 6; x < 10; x++) {
tenSeconds.$obj.find('li:last-child').remove();
tenMinutes.$obj.find('li:last-child').remove();
}
}
});
}(jQuery));
(function ($) {
/**
* FlipClock Arabic Language Pack
*
* This class will be used to translate tokens into the Arabic language.
*
*/
FlipClock.Lang.Arabic = {
'years': 'سنوات',
'months': 'شهور',
'days': 'أيام',
'hours': 'ساعات',
'minutes': 'دقائق',
'seconds': 'ثواني'
};
/* Create various aliases for convenience */
FlipClock.Lang['ar'] = FlipClock.Lang.Arabic;
FlipClock.Lang['ar-ar'] = FlipClock.Lang.Arabic;
FlipClock.Lang['arabic'] = FlipClock.Lang.Arabic;
}(jQuery));
(function ($) {
/**
* FlipClock Danish Language Pack
*
* This class will used to translate tokens into the Danish language.
*
*/
FlipClock.Lang.Danish = {
'years': 'År',
'months': 'Måneder',
'days': 'Dage',
'hours': 'Timer',
'minutes': 'Minutter',
'seconds': 'Sekunder'
};
/* Create various aliases for convenience */
FlipClock.Lang['da'] = FlipClock.Lang.Danish;
FlipClock.Lang['da-dk'] = FlipClock.Lang.Danish;
FlipClock.Lang['danish'] = FlipClock.Lang.Danish;
}(jQuery));
(function ($) {
/**
* FlipClock German Language Pack
*
* This class will used to translate tokens into the German language.
*
*/
FlipClock.Lang.German = {
'years': 'Jahre',
'months': 'Monate',
'days': 'Tage',
'hours': 'Stunden',
'minutes': 'Minuten',
'seconds': 'Sekunden'
};
/* Create various aliases for convenience */
FlipClock.Lang['de'] = FlipClock.Lang.German;
FlipClock.Lang['de-de'] = FlipClock.Lang.German;
FlipClock.Lang['german'] = FlipClock.Lang.German;
}(jQuery));
(function ($) {
/**
* FlipClock English Language Pack
*
* This class will used to translate tokens into the English language.
*
*/
FlipClock.Lang.English = {
'years': 'Years',
'months': 'Months',
'days': 'Days',
'hours': 'Hours',
'minutes': 'Minutes',
'seconds': 'Seconds'
};
/* Create various aliases for convenience */
FlipClock.Lang['en'] = FlipClock.Lang.English;
FlipClock.Lang['en-us'] = FlipClock.Lang.English;
FlipClock.Lang['english'] = FlipClock.Lang.English;
}(jQuery));
(function ($) {
/**
* FlipClock Spanish Language Pack
*
* This class will used to translate tokens into the Spanish language.
*
*/
FlipClock.Lang.Spanish = {
'years': 'Años',
'months': 'Meses',
'days': 'DÍas',
'hours': 'Horas',
'minutes': 'Minutos',
'seconds': 'Segundo'
};
/* Create various aliases for convenience */
FlipClock.Lang['es'] = FlipClock.Lang.Spanish;
FlipClock.Lang['es-es'] = FlipClock.Lang.Spanish;
FlipClock.Lang['spanish'] = FlipClock.Lang.Spanish;
}(jQuery));
(function ($) {
/**
* FlipClock Canadian French Language Pack
*
* This class will used to translate tokens into the Canadian French language.
*
*/
FlipClock.Lang.French = {
'years': 'Ans',
'months': 'Mois',
'days': 'Jours',
'hours': 'Heures',
'minutes': 'Minutes',
'seconds': 'Secondes'
};
/* Create various aliases for convenience */
FlipClock.Lang['fr'] = FlipClock.Lang.French;
FlipClock.Lang['fr-ca'] = FlipClock.Lang.French;
FlipClock.Lang['french'] = FlipClock.Lang.French;
}(jQuery));
(function ($) {
/**
* FlipClock Italian Language Pack
*
* This class will used to translate tokens into the Italian language.
*
*/
FlipClock.Lang.Italian = {
'years': 'Anni',
'months': 'Mesi',
'days': 'Giorni',
'hours': 'Ore',
'minutes': 'Minuti',
'seconds': 'Secondi'
};
/* Create various aliases for convenience */
FlipClock.Lang['it'] = FlipClock.Lang.Italian;
FlipClock.Lang['it-it'] = FlipClock.Lang.Italian;
FlipClock.Lang['italian'] = FlipClock.Lang.Italian;
}(jQuery));
(function ($) {
/**
* FlipClock Latvian Language Pack
*
* This class will used to translate tokens into the Latvian language.
*
*/
FlipClock.Lang.Latvian = {
'years': 'Gadi',
'months': 'Mēneši',
'days': 'Dienas',
'hours': 'Stundas',
'minutes': 'Minūtes',
'seconds': 'Sekundes'
};
/* Create various aliases for convenience */
FlipClock.Lang['lv'] = FlipClock.Lang.Latvian;
FlipClock.Lang['lv-lv'] = FlipClock.Lang.Latvian;
FlipClock.Lang['latvian'] = FlipClock.Lang.Latvian;
}(jQuery));
(function ($) {
/**
* FlipClock Dutch Language Pack
*
* This class will used to translate tokens into the Dutch language.
*/
FlipClock.Lang.Dutch = {
'years': 'Jaren',
'months': 'Maanden',
'days': 'Dagen',
'hours': 'Uren',
'minutes': 'Minuten',
'seconds': 'Seconden'
};
/* Create various aliases for convenience */
FlipClock.Lang['nl'] = FlipClock.Lang.Dutch;
FlipClock.Lang['nl-be'] = FlipClock.Lang.Dutch;
FlipClock.Lang['dutch'] = FlipClock.Lang.Dutch;
}(jQuery));
(function ($) {
/**
* FlipClock Russian Language Pack
*
* This class will used to translate tokens into the Russian language.
*
*/
FlipClock.Lang.Russian = {
'years': 'лет',
'months': 'месяцев',
'days': 'дней',
'hours': 'часов',
'minutes': 'минут',
'seconds': 'секунд'
};
/* Create various aliases for convenience */
FlipClock.Lang['ru'] = FlipClock.Lang.Russian;
FlipClock.Lang['ru-ru'] = FlipClock.Lang.Russian;
FlipClock.Lang['russian'] = FlipClock.Lang.Russian;
}(jQuery));
(function ($) {
/**
* FlipClock Swedish Language Pack
*
* This class will used to translate tokens into the Swedish language.
*
*/
FlipClock.Lang.Swedish = {
'years': 'År',
'months': 'Månader',
'days': 'Dagar',
'hours': 'Timmar',
'minutes': 'Minuter',
'seconds': 'Sekunder'
};
/* Create various aliases for convenience */
FlipClock.Lang['sv'] = FlipClock.Lang.Danish;
FlipClock.Lang['sv-se'] = FlipClock.Lang.Danish;
FlipClock.Lang['swedish'] = FlipClock.Lang.Danish;
}(jQuery));
/**************************************/
// Code added by Asim Ashraf - DevBatch
// DateTime: 28 Jan 2015
// Code Edit Start
/************************************/
(function ($) {
FlipClock.Resize = function () {
jQuery(".flipclock").each(function () {
var $this = jQuery(this);
var col_width = $this.width(); //console.log(col_width);
if (col_width > 546) {
$this.find(".flipclock_inner").css({'min-width': '460px'});
$this.find('.flip-clock-wrapper ul').removeAttr('style');
$this.find('.flip-clock-wrapper ul li a div div.inn').removeAttr('style');
$this.find('.flip-clock-wrapper ul li a div.up:after').removeAttr('style');
$this.find('.flip-clock-divider').removeAttr('style');
$this.find('.flip-clock-dot').removeAttr('style');
$this.find('.flip-clock-dot.top').removeAttr('style');
$this.find('.flip-clock-dot.bottom').removeAttr('style');
$this.find('.flip-clock-divider .flip-clock-label').removeAttr('style');
$this.find('.flip-clock-divider.days .flip-clock-label').removeAttr('style');
$this.find('.flip-clock-divider.hours .flip-clock-label').removeAttr('style');
$this.find('.flip-clock-divider.minutes .flip-clock-label').removeAttr('style');
$this.find('.flip-clock-divider.seconds .flip-clock-label').removeAttr('style');
} else {
var ul_width = col_width / 12;
var ul_height = ul_width + 20;
var font_size = ul_height / 2;
var dot_size = (ul_width - font_size - 2);
dot_size = dot_size < 6 ? 6 : dot_size;
$this.find(".flipclock_inner").css({'min-width': '', "margin-left": "-" + (dot_size + 2) + "px"});
$this.find(".flip-clock-wrapper ul").css({"width": ul_width + "px", "height": ul_height + "px", "line-height": ul_height + "px", "margin": "5px 2px"});
$this.find(".flip-clock-wrapper ul li a div div.inn").css({"font-size": font_size + "px", "width": "99%"});
$this.find(".flip-clock-wrapper ul li a div.up:after").css({"top": (ul_height / 2) + "px"});
$this.find(".flip-clock-divider").css({"height": ul_height + "px", "width": (dot_size + 2) + "px"});
$this.find(".flip-clock-dot").css({"height": dot_size + "px", "width": dot_size + "px", "left": ((dot_size + 2) - dot_size - 1) + "px"});
$this.find(".flip-clock-dot.top").css({"top": (font_size - 5) + "px"});
$this.find(".flip-clock-dot.bottom").css({"bottom": (font_size - (dot_size * 2)) + "px"});
$this.find(".flip-clock-divider .flip-clock-label").css({"font-size": (font_size / 2) + "px"}); //console.log(ul_width+":"+font_size);
$this.find(".flip-clock-divider.days .flip-clock-label").css({"bottom": (font_size * -1) + "px", "left": (ul_width - (font_size / 2) - (dot_size + 2)) + "px", "width": (ul_width * 2) + "px"});
$this.find(".flip-clock-divider.hours .flip-clock-label").css({"bottom": (font_size * -1) + "px", "left": (ul_width - (font_size / 2) - (dot_size + 2)) + "px", "width": (ul_width * 2) + "px"});
$this.find(".flip-clock-divider.minutes .flip-clock-label").css({"bottom": (font_size * -1) + "px", "left": (ul_width - (font_size / 2) - (dot_size + 2)) + "px", "width": (ul_width * 2) + "px"});
$this.find(".flip-clock-divider.seconds .flip-clock-label").css({"bottom": (font_size * -1) + "px", "left": (ul_width - (font_size / 2) - (dot_size + 2)) + "px", "width": (ul_width * 2) + "px"});
}
});
}
}(jQuery));
/**************************************/
// Code added by Asim Ashraf - DevBatch
// DateTime: 28 Jan 2015
// Code Edit End
/************************************/