Accessories & ShoesWomen's Apparel
Men'sShop by Brand
Shop by MaterialShop by Designer & Brand
Shop by Brand
KitchenFood
Shop by Brand
Home Decor
Home Improvement
- Cleaning
- Floorcare & Vacuums
- Garden Center
- Grills
- Home Environment
- Home Projects
- Laundry & Closet
- Outdoor Living
- Tools
Electronics
Shop by Brand
Toys
Shop By AgeShop By Brand
QVC : Product Detail
F02086
Description
Walk your way to a healthier you! Your stepping motion provides the power for a lower body workout on this manual treadmill. It features a generous 42" surface for running or walking, and a large LCD display that shows your time, speed, distance, and calories burned. From Cory Everson.
As always, please consult your personal physician before beginning any diet or exercise program.
As always, please consult your personal physician before beginning any diet or exercise program.
- Includes treadmill, MP3 player/cell phone pouch, and 2 AA batteries
- Quiet operation
- Water-bottle holder
- Folds for storage
- Steel construction
- Approximate measurements: Upright, 47"L x 25"W x 47"H; Folded, 12"L x 25"W x 49"H
- Supports up to 250 lbs
- 90-day Limited Manufacturer's Warranty
- Made in China
Delivery Date Estimate
Estimate Delivery Dates for:F02086 - Cory Everson Manual Folding Treadmill with LCD Display
To choose your shipping method, add this item to your Shopping Cart, continue to Standard Check-Out, and make your selection on the Shipping Method page.
Print this page
Email this page to a friendCustomer Reviews
 |
|
|
|
||||||||||||||||||||||||||||
|
| 1-4 of 38 | More Reviews |
Browse More Items
You May Also Like
- LIBERTY MEDIA FAMILY:
- Outdoor Gear from Backcountry.com|
- Flowers from ProFlowers.com|
- Halloween Costumes from BuyCostumes.com
(end)
*/
setProperties: function(source){
return Element.setMany(this, 'setProperty', source);
},
/*
Property: setHTML
Sets the innerHTML of the Element.
Arguments:
html - string; the new innerHTML for the element.
Example:
>$('myElement').setHTML(newHTML) //the innerHTML of myElement is now = newHTML
*/
setHTML: function(){
this.innerHTML = $A(arguments).join('');
return this;
},
/*
Property: setText
Sets the inner text of the Element.
Arguments:
text - string; the new text content for the element.
Example:
>$('myElement').setText('some text') //the text of myElement is now = 'some text'
*/
setText: function(text){
var tag = this.getTag();
if (['style', 'script'].contains(tag)){
if (window.ie){
if (tag == 'style') this.styleSheet.cssText = text;
else if (tag == 'script') this.setProperty('text', text);
return this;
} else {
this.removeChild(this.firstChild);
return this.appendText(text);
}
}
this[$defined(this.innerText) ? 'innerText' : 'textContent'] = text;
return this;
},
/*
Property: getText
Gets the inner text of the Element.
*/
getText: function(){
var tag = this.getTag();
if (['style', 'script'].contains(tag)){
if (window.ie){
if (tag == 'style') return this.styleSheet.cssText;
else if (tag == 'script') return this.getProperty('text');
} else {
return this.innerHTML;
}
}
return ($pick(this.innerText, this.textContent));
},
/*
Property: getTag
Returns the tagName of the element in lower case.
Example:
>$('myImage').getTag() // returns 'img'
Returns:
The tag name in lower case
*/
getTag: function(){
return this.tagName.toLowerCase();
},
/*
Property: empty
Empties an element of all its children.
Example:
>$('myDiv').empty() // empties the Div and returns it
Returns:
The element.
*/
empty: function(){
Garbage.trash(this.getElementsByTagName('*'));
return this.setHTML('');
}
});
Element.fixStyle = function(property, result, element){
if ($chk(parseInt(result))) return result;
if (['height', 'width'].contains(property)){
var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'];
var size = 0;
values.each(function(value){
size += element.getStyle('border-' + value + '-width').toInt() + element.getStyle('padding-' + value).toInt();
});
return element['offset' + property.capitalize()] - size + 'px';
} else if (property.test(/border(.+)Width|margin|padding/)){
return '0px';
}
return result;
};
Element.Styles = {'border': [], 'padding': [], 'margin': []};
['Top', 'Right', 'Bottom', 'Left'].each(function(direction){
for (var style in Element.Styles) Element.Styles[style].push(style + direction);
});
Element.borderShort = ['borderWidth', 'borderStyle', 'borderColor'];
Element.getMany = function(el, method, keys){
var result = {};
$each(keys, function(key){
result[key] = el[method](key);
});
return result;
};
Element.setMany = function(el, method, pairs){
for (var key in pairs) el[method](key, pairs[key]);
return el;
};
Element.Properties = new Abstract({
'class': 'className', 'for': 'htmlFor', 'colspan': 'colSpan', 'rowspan': 'rowSpan',
'accesskey': 'accessKey', 'tabindex': 'tabIndex', 'maxlength': 'maxLength',
'readonly': 'readOnly', 'frameborder': 'frameBorder', 'value': 'value',
'disabled': 'disabled', 'checked': 'checked', 'multiple': 'multiple', 'selected': 'selected'
});
Element.PropertiesIFlag = {
'href': 2, 'src': 2
};
Element.Methods = {
Listeners: {
addListener: function(type, fn){
if (this.addEventListener) this.addEventListener(type, fn, false);
else this.attachEvent('on' + type, fn);
return this;
},
removeListener: function(type, fn){
if (this.removeEventListener) this.removeEventListener(type, fn, false);
else this.detachEvent('on' + type, fn);
return this;
}
}
};
window.extend(Element.Methods.Listeners);
document.extend(Element.Methods.Listeners);
Element.extend(Element.Methods.Listeners);
var Garbage = {
elements: [],
collect: function(el){
if (!el.$tmp){
Garbage.elements.push(el);
el.$tmp = {'opacity': 1};
}
return el;
},
trash: function(elements){
for (var i = 0, j = elements.length, el; i < j; i++){
if (!(el = elements[i]) || !el.$tmp) continue;
if (el.$events) el.fireEvent('trash').removeEvents();
for (var p in el.$tmp) el.$tmp[p] = null;
for (var d in Element.prototype) el[d] = null;
Garbage.elements[Garbage.elements.indexOf(el)] = null;
el.htmlElement = el.$tmp = el = null;
}
Garbage.elements.remove(null);
},
empty: function(){
Garbage.collect(window);
Garbage.collect(document);
Garbage.trash(Garbage.elements);
}
};
window.addListener('beforeunload', function(){
window.addListener('unload', Garbage.empty);
if (window.ie) window.addListener('unload', CollectGarbage);
});
/*
Script: Element.Event.js
Contains the Event Class, Element methods to deal with Element events, custom Events, and the Function prototype bindWithEvent.
License:
MIT-style license.
*/
/*
Class: Event
Cross browser methods to manage events.
Arguments:
event - the event
Properties:
shift - true if the user pressed the shift
control - true if the user pressed the control
alt - true if the user pressed the alt
meta - true if the user pressed the meta key
wheel - the amount of third button scrolling
code - the keycode of the key pressed
page.x - the x position of the mouse, relative to the full window
page.y - the y position of the mouse, relative to the full window
client.x - the x position of the mouse, relative to the viewport
client.y - the y position of the mouse, relative to the viewport
key - the key pressed as a lowercase string. key also returns 'enter', 'up', 'down', 'left', 'right', 'space', 'backspace', 'delete', 'esc'. Handy for these special keys.
target - the event target
relatedTarget - the event related target
Example:
(start code)
$('myLink').onkeydown = function(event){
var event = new Event(event);
//event is now the Event class.
alert(event.key); //returns the lowercase letter pressed
alert(event.shift); //returns true if the key pressed is shift
if (event.key == 's' && event.control) alert('document saved');
};
(end)
*/
var Event = new Class({
initialize: function(event){
if (event && event.$extended) return event;
this.$extended = true;
event = event || window.event;
this.event = event;
this.type = event.type;
this.target = event.target || event.srcElement;
if (this.target.nodeType == 3) this.target = this.target.parentNode;
this.shift = event.shiftKey;
this.control = event.ctrlKey;
this.alt = event.altKey;
this.meta = event.metaKey;
if (['DOMMouseScroll', 'mousewheel'].contains(this.type)){
this.wheel = (event.wheelDelta) ? event.wheelDelta / 120 : -(event.detail || 0) / 3;
} else if (this.type.contains('key')){
this.code = event.which || event.keyCode;
for (var name in Event.keys){
if (Event.keys[name] == this.code){
this.key = name;
break;
}
}
if (this.type == 'keydown'){
var fKey = this.code - 111;
if (fKey > 0 && fKey < 13) this.key = 'f' + fKey;
}
this.key = this.key || String.fromCharCode(this.code).toLowerCase();
} else if (this.type.test(/(click|mouse|menu)/)){
this.page = {
'x': event.pageX || event.clientX + document.documentElement.scrollLeft,
'y': event.pageY || event.clientY + document.documentElement.scrollTop
};
this.client = {
'x': event.pageX ? event.pageX - window.pageXOffset : event.clientX,
'y': event.pageY ? event.pageY - window.pageYOffset : event.clientY
};
this.rightClick = (event.which == 3) || (event.button == 2);
switch(this.type){
case 'mouseover': this.relatedTarget = event.relatedTarget || event.fromElement; break;
case 'mouseout': this.relatedTarget = event.relatedTarget || event.toElement;
}
this.fixRelatedTarget();
}
return this;
},
/*
Property: stop
cross browser method to stop an event
*/
stop: function(){
return this.stopPropagation().preventDefault();
},
/*
Property: stopPropagation
cross browser method to stop the propagation of an event
*/
stopPropagation: function(){
if (this.event.stopPropagation) this.event.stopPropagation();
else this.event.cancelBubble = true;
return this;
},
/*
Property: preventDefault
cross browser method to prevent the default action of the event
*/
preventDefault: function(){
if (this.event.preventDefault) this.event.preventDefault();
else this.event.returnValue = false;
return this;
}
});
Event.fix = {
relatedTarget: function(){
if (this.relatedTarget && this.relatedTarget.nodeType == 3) this.relatedTarget = this.relatedTarget.parentNode;
},
relatedTargetGecko: function(){
try {Event.fix.relatedTarget.call(this);} catch(e){this.relatedTarget = this.target;}
}
};
Event.prototype.fixRelatedTarget = (window.gecko) ? Event.fix.relatedTargetGecko : Event.fix.relatedTarget;
/*
Property: keys
you can add additional Event keys codes this way:
Example:
(start code)
Event.keys.whatever = 80;
$(myelement).addEvent(keydown, function(event){
event = new Event(event);
if (event.key == 'whatever') console.log(whatever key clicked).
});
(end)
*/
Event.keys = new Abstract({
'enter': 13,
'up': 38,
'down': 40,
'left': 37,
'right': 39,
'esc': 27,
'space': 32,
'backspace': 8,
'tab': 9,
'delete': 46
});
/*
Class: Element
Custom class to allow all of its methods to be used with any DOM element via the dollar function <$>.
*/
Element.Methods.Events = {
/*
Property: addEvent
Attaches an event listener to a DOM element.
Arguments:
type - the event to monitor ('click', 'load', etc) without the prefix 'on'.
fn - the function to execute
Example:
>$('myElement').addEvent('click', function(){alert('clicked!')});
*/
addEvent: function(type, fn){
this.$events = this.$events || {};
this.$events[type] = this.$events[type] || {'keys': [], 'values': []};
if (this.$events[type].keys.contains(fn)) return this;
this.$events[type].keys.push(fn);
var realType = type;
var custom = Element.Events[type];
if (custom){
if (custom.add) custom.add.call(this, fn);
if (custom.map) fn = custom.map;
if (custom.type) realType = custom.type;
}
if (!this.addEventListener) fn = fn.create({'bind': this, 'event': true});
this.$events[type].values.push(fn);
return (Element.NativeEvents.contains(realType)) ? this.addListener(realType, fn) : this;
},
/*
Property: removeEvent
Works as Element.addEvent, but instead removes the previously added event listener.
*/
removeEvent: function(type, fn){
if (!this.$events || !this.$events[type]) return this;
var pos = this.$events[type].keys.indexOf(fn);
if (pos == -1) return this;
var key = this.$events[type].keys.splice(pos,1)[0];
var value = this.$events[type].values.splice(pos,1)[0];
var custom = Element.Events[type];
if (custom){
if (custom.remove) custom.remove.call(this, fn);
if (custom.type) type = custom.type;
}
return (Element.NativeEvents.contains(type)) ? this.removeListener(type, value) : this;
},
/*
Property: addEvents
As 
(end)
Note:
The title of the element will always be used as the tooltip body. If you put :: on your title, the text before :: will become the tooltip title.
*/
var Tips = new Class({
options: {
onShow: function(tip){
tip.setStyle('visibility', 'visible');
},
onHide: function(tip){
tip.setStyle('visibility', 'hidden');
},
maxTitleChars: 30,
showDelay: 100,
hideDelay: 100,
className: 'tool',
offsets: {'x': 16, 'y': 16},
fixed: false
},
initialize: function(elements, options){
this.setOptions(options);
this.toolTip = new Element('div', {
'class': this.options.className + '-tip',
'styles': {
'position': 'absolute',
'top': '0',
'left': '0',
'visibility': 'hidden'
}
}).inject(document.body);
this.wrapper = new Element('div').inject(this.toolTip);
$$(elements).each(this.build, this);
if (this.options.initialize) this.options.initialize.call(this);
},
build: function(el){
el.$tmp.myTitle = (el.href && el.getTag() == 'a') ? el.href.replace('http://', '') : (el.rel || false);
if (el.title){
var dual = el.title.split('::');
if (dual.length > 1){
el.$tmp.myTitle = dual[0].trim();
el.$tmp.myText = dual[1].trim();
} else {
el.$tmp.myText = el.title;
}
el.removeAttribute('title');
} else {
el.$tmp.myText = false;
}
if (el.$tmp.myTitle && el.$tmp.myTitle.length > this.options.maxTitleChars) el.$tmp.myTitle = el.$tmp.myTitle.substr(0, this.options.maxTitleChars - 1) + "…";
el.addEvent('mouseenter', function(event){
this.start(el);
if (!this.options.fixed) this.locate(event);
else this.position(el);
}.bind(this));
if (!this.options.fixed) el.addEvent('mousemove', this.locate.bindWithEvent(this));
var end = this.end.bind(this);
el.addEvent('mouseleave', end);
el.addEvent('trash', end);
},
start: function(el){
this.wrapper.empty();
if (el.$tmp.myTitle){
this.title = new Element('span').inject(new Element('div', {'class': this.options.className + '-title'}).inject(this.wrapper)).setHTML(el.$tmp.myTitle);
}
if (el.$tmp.myText){
this.text = new Element('span').inject(new Element('div', {'class': this.options.className + '-text'}).inject(this.wrapper)).setHTML(el.$tmp.myText);
}
$clear(this.timer);
this.timer = this.show.delay(this.options.showDelay, this);
},
end: function(event){
$clear(this.timer);
this.timer = this.hide.delay(this.options.hideDelay, this);
},
position: function(element){
var pos = element.getPosition();
this.toolTip.setStyles({
'left': pos.x + this.options.offsets.x,
'top': pos.y + this.options.offsets.y
});
},
locate: function(event){
var win = {'x': window.getWidth(), 'y': window.getHeight()};
var scroll = {'x': window.getScrollLeft(), 'y': window.getScrollTop()};
var tip = {'x': this.toolTip.offsetWidth, 'y': this.toolTip.offsetHeight};
var prop = {'x': 'left', 'y': 'top'};
for (var z in prop){
var pos = event.page[z] + this.options.offsets[z];
if ((pos + tip[z] - scroll[z]) > win[z]) pos = event.page[z] - this.options.offsets[z] - tip[z];
this.toolTip.setStyle(prop[z], pos);
};
},
show: function(){
if (this.options.timeout) this.timer = this.hide.delay(this.options.timeout, this);
this.fireEvent('onShow', [this.toolTip]);
},
hide: function(){
this.fireEvent('onHide', [this.toolTip]);
}
});
Tips.implement(new Events, new Options);
/*
Script: Group.js
For Grouping Classes or Elements Events. The Event added to the Group will fire when all of the events of the items of the group are fired.
License:
MIT-style license.
*/
/*
Class: Group
An "Utility" Class.
Arguments:
List of Class instances
Example:
(start code)
xhr1 = new Ajax('data.js', {evalScript: true});
xhr2 = new Ajax('abstraction.js', {evalScript: true});
xhr3 = new Ajax('template.js', {evalScript: true});
var group = new Group(xhr1, xhr2, xhr3);
group.addEvent('onComplete', function(){
alert('All Scripts loaded');
});
xhr1.request();
xhr2.request();
xhr3.request();
(end)
*/
var Group = new Class({
initialize: function(){
this.instances = $A(arguments);
this.events = {};
this.checker = {};
},
/*
Property: addEvent
adds an event to the stack of events of the Class instances.
Arguments:
type - string; the event name (e.g. 'onComplete')
fn - function to execute when all instances fired this event
*/
addEvent: function(type, fn){
this.checker[type] = this.checker[type] || {};
this.events[type] = this.events[type] || [];
if (this.events[type].contains(fn)) return false;
else this.events[type].push(fn);
this.instances.each(function(instance, i){
instance.addEvent(type, this.check.bind(this, [type, instance, i]));
}, this);
return this;
},
check: function(type, instance, i){
this.checker[type][i] = true;
var every = this.instances.every(function(current, j){
return this.checker[type][j] || false;
}, this);
if (!every) return;
this.checker[type] = {};
this.events[type].each(function(event){
event.call(this, this.instances, instance);
}, this);
}
});
/*
Script: Accordion.js
Contains 
";
TB_load_position();
new Fx.Style('TB_overlay', 'opacity',{duration: 400, transition: Fx.Transitions.sineInOut}).start(0,0.6);
}
if ( !$("TB_load") )
{
new Element('div').setProperty('id', 'TB_load').injectInside(document.body);
$('TB_load').innerHTML = "