Publicado em 10 de set.

Contador regressivo sem resetar ao dar refresh na página

#perguntas-e-respostas-rapidas #contador #jquery #pagina #refresh

Pessoal, estou usando o Flipclock para fazer um contador regressivo para um site EM CONSTRUÇÃO. Deu tudo certo, mas ao atualizar a página o contador regressivo reseta.

<html>
	<head>
 <link rel="stylesheet" href="compiled/flipclock.css">

 <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>

 <script src="compiled/flipclock.js"></script>
	</head>
	<body>
	<div class="clock"></div>
	<div class="message"></div>

	<script type="text/javascript">
 var clock;

 $(document).ready(function() {
 var clock;

 clock = $('.clock').FlipClock({
 clockFace: 'DailyCounter',
 autoStart: false,
 callbacks: {
 reset: function() {

 }
 }
 });

 clock.setTime(3974400);
 clock.setCountdown(true);
 clock.start();

 });
	</script>

	</body>
</html>

/*
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;