I printed most of the upgrades

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/effects.js

@@ -0,0 +1,903 @@
+// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+// Contributors:
+//  Justin Palmer (http://encytemedia.com/)
+//  Mark Pilgrim (http://diveintomark.org/)
+//  Martin Bialasinki
+// 
+// See scriptaculous.js for full license.  
+
+/* ------------- element ext -------------- */  
+ 
+// converts rgb() and #xxx to #xxxxxx format,  
+// returns self (or first argument) if not convertable  
+String.prototype.parseColor = function() {  
+  var color = '#';  
+  if(this.slice(0,4) == 'rgb(') {  
+    var cols = this.slice(4,this.length-1).split(',');  
+    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);  
+  } else {  
+    if(this.slice(0,1) == '#') {  
+      if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();  
+      if(this.length==7) color = this.toLowerCase();  
+    }  
+  }  
+  return(color.length==7 ? color : (arguments[0] || this));  
+}
+
+Element.collectTextNodes = function(element) {  
+  return $A($(element).childNodes).collect( function(node) {
+    return (node.nodeType==3 ? node.nodeValue : 
+      (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
+  }).flatten().join('');
+}
+
+Element.collectTextNodesIgnoreClass = function(element, className) {  
+  return $A($(element).childNodes).collect( function(node) {
+    return (node.nodeType==3 ? node.nodeValue : 
+      ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
+        Element.collectTextNodes(node) : ''));
+  }).flatten().join('');
+}
+
+Element.setStyle = function(element, style) {
+  element = $(element);
+  for(k in style) element.style[k.camelize()] = style[k];
+}
+
+Element.setContentZoom = function(element, percent) {  
+  Element.setStyle(element, {fontSize: (percent/100) + 'em'});   
+  if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);  
+}
+
+Element.getOpacity = function(element){  
+  var opacity;
+  if (opacity = Element.getStyle(element, 'opacity'))  
+    return parseFloat(opacity);  
+  if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/))  
+    if(opacity[1]) return parseFloat(opacity[1]) / 100;  
+  return 1.0;  
+}
+
+Element.setOpacity = function(element, value){  
+  element= $(element);  
+  if (value == 1){
+    Element.setStyle(element, { opacity: 
+      (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
+      0.999999 : null });
+    if(/MSIE/.test(navigator.userAgent))  
+      Element.setStyle(element, {filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});  
+  } else {  
+    if(value < 0.00001) value = 0;  
+    Element.setStyle(element, {opacity: value});
+    if(/MSIE/.test(navigator.userAgent))  
+     Element.setStyle(element, 
+       { filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
+                 'alpha(opacity='+value*100+')' });  
+  }   
+}  
+ 
+Element.getInlineOpacity = function(element){  
+  return $(element).style.opacity || '';
+}  
+
+Element.childrenWithClassName = function(element, className) {  
+  return $A($(element).getElementsByTagName('*')).select(
+    function(c) { return Element.hasClassName(c, className) });
+}
+
+Array.prototype.call = function() {
+  var args = arguments;
+  this.each(function(f){ f.apply(this, args) });
+}
+
+/*--------------------------------------------------------------------------*/
+
+var Effect = {
+  tagifyText: function(element) {
+    var tagifyStyle = 'position:relative';
+    if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
+    element = $(element);
+    $A(element.childNodes).each( function(child) {
+      if(child.nodeType==3) {
+        child.nodeValue.toArray().each( function(character) {
+          element.insertBefore(
+            Builder.node('span',{style: tagifyStyle},
+              character == ' ' ? String.fromCharCode(160) : character), 
+              child);
+        });
+        Element.remove(child);
+      }
+    });
+  },
+  multiple: function(element, effect) {
+    var elements;
+    if(((typeof element == 'object') || 
+        (typeof element == 'function')) && 
+       (element.length))
+      elements = element;
+    else
+      elements = $(element).childNodes;
+      
+    var options = Object.extend({
+      speed: 0.1,
+      delay: 0.0
+    }, arguments[2] || {});
+    var masterDelay = options.delay;
+
+    $A(elements).each( function(element, index) {
+      new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
+    });
+  },
+  PAIRS: {
+    'slide':  ['SlideDown','SlideUp'],
+    'blind':  ['BlindDown','BlindUp'],
+    'appear': ['Appear','Fade']
+  },
+  toggle: function(element, effect) {
+    element = $(element);
+    effect = (effect || 'appear').toLowerCase();
+    var options = Object.extend({
+      queue: { position:'end', scope:(element.id || 'global') }
+    }, arguments[2] || {});
+    Effect[Element.visible(element) ? 
+      Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
+  }
+};
+
+var Effect2 = Effect; // deprecated
+
+/* ------------- transitions ------------- */
+
+Effect.Transitions = {}
+
+Effect.Transitions.linear = function(pos) {
+  return pos;
+}
+Effect.Transitions.sinoidal = function(pos) {
+  return (-Math.cos(pos*Math.PI)/2) + 0.5;
+}
+Effect.Transitions.reverse  = function(pos) {
+  return 1-pos;
+}
+Effect.Transitions.flicker = function(pos) {
+  return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
+}
+Effect.Transitions.wobble = function(pos) {
+  return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
+}
+Effect.Transitions.pulse = function(pos) {
+  return (Math.floor(pos*10) % 2 == 0 ? 
+    (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
+}
+Effect.Transitions.none = function(pos) {
+  return 0;
+}
+Effect.Transitions.full = function(pos) {
+  return 1;
+}
+
+/* ------------- core effects ------------- */
+
+Effect.ScopedQueue = Class.create();
+Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
+  initialize: function() {
+    this.effects  = [];
+    this.interval = null;
+  },
+  _each: function(iterator) {
+    this.effects._each(iterator);
+  },
+  add: function(effect) {
+    var timestamp = new Date().getTime();
+    
+    var position = (typeof effect.options.queue == 'string') ? 
+      effect.options.queue : effect.options.queue.position;
+    
+    switch(position) {
+      case 'front':
+        // move unstarted effects after this effect  
+        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
+            e.startOn  += effect.finishOn;
+            e.finishOn += effect.finishOn;
+          });
+        break;
+      case 'end':
+        // start effect after last queued effect has finished
+        timestamp = this.effects.pluck('finishOn').max() || timestamp;
+        break;
+    }
+    
+    effect.startOn  += timestamp;
+    effect.finishOn += timestamp;
+    this.effects.push(effect);
+    if(!this.interval) 
+      this.interval = setInterval(this.loop.bind(this), 40);
+  },
+  remove: function(effect) {
+    this.effects = this.effects.reject(function(e) { return e==effect });
+    if(this.effects.length == 0) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  },
+  loop: function() {
+    var timePos = new Date().getTime();
+    this.effects.invoke('loop', timePos);
+  }
+});
+
+Effect.Queues = {
+  instances: $H(),
+  get: function(queueName) {
+    if(typeof queueName != 'string') return queueName;
+    
+    if(!this.instances[queueName])
+      this.instances[queueName] = new Effect.ScopedQueue();
+      
+    return this.instances[queueName];
+  }
+}
+Effect.Queue = Effect.Queues.get('global');
+
+Effect.DefaultOptions = {
+  transition: Effect.Transitions.sinoidal,
+  duration:   1.0,   // seconds
+  fps:        25.0,  // max. 25fps due to Effect.Queue implementation
+  sync:       false, // true for combining
+  from:       0.0,
+  to:         1.0,
+  delay:      0.0,
+  queue:      'parallel'
+}
+
+Effect.Base = function() {};
+Effect.Base.prototype = {
+  position: null,
+  start: function(options) {
+    this.options      = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
+    this.currentFrame = 0;
+    this.state        = 'idle';
+    this.startOn      = this.options.delay*1000;
+    this.finishOn     = this.startOn + (this.options.duration*1000);
+    this.event('beforeStart');
+    if(!this.options.sync)
+      Effect.Queues.get(typeof this.options.queue == 'string' ? 
+        'global' : this.options.queue.scope).add(this);
+  },
+  loop: function(timePos) {
+    if(timePos >= this.startOn) {
+      if(timePos >= this.finishOn) {
+        this.render(1.0);
+        this.cancel();
+        this.event('beforeFinish');
+        if(this.finish) this.finish(); 
+        this.event('afterFinish');
+        return;  
+      }
+      var pos   = (timePos - this.startOn) / (this.finishOn - this.startOn);
+      var frame = Math.round(pos * this.options.fps * this.options.duration);
+      if(frame > this.currentFrame) {
+        this.render(pos);
+        this.currentFrame = frame;
+      }
+    }
+  },
+  render: function(pos) {
+    if(this.state == 'idle') {
+      this.state = 'running';
+      this.event('beforeSetup');
+      if(this.setup) this.setup();
+      this.event('afterSetup');
+    }
+    if(this.state == 'running') {
+      if(this.options.transition) pos = this.options.transition(pos);
+      pos *= (this.options.to-this.options.from);
+      pos += this.options.from;
+      this.position = pos;
+      this.event('beforeUpdate');
+      if(this.update) this.update(pos);
+      this.event('afterUpdate');
+    }
+  },
+  cancel: function() {
+    if(!this.options.sync)
+      Effect.Queues.get(typeof this.options.queue == 'string' ? 
+        'global' : this.options.queue.scope).remove(this);
+    this.state = 'finished';
+  },
+  event: function(eventName) {
+    if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
+    if(this.options[eventName]) this.options[eventName](this);
+  },
+  inspect: function() {
+    return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
+  }
+}
+
+Effect.Parallel = Class.create();
+Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
+  initialize: function(effects) {
+    this.effects = effects || [];
+    this.start(arguments[1]);
+  },
+  update: function(position) {
+    this.effects.invoke('render', position);
+  },
+  finish: function(position) {
+    this.effects.each( function(effect) {
+      effect.render(1.0);
+      effect.cancel();
+      effect.event('beforeFinish');
+      if(effect.finish) effect.finish(position);
+      effect.event('afterFinish');
+    });
+  }
+});
+
+Effect.Opacity = Class.create();
+Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    // make this work on IE on elements without 'layout'
+    if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
+      Element.setStyle(this.element, {zoom: 1});
+    var options = Object.extend({
+      from: Element.getOpacity(this.element) || 0.0,
+      to:   1.0
+    }, arguments[1] || {});
+    this.start(options);
+  },
+  update: function(position) {
+    Element.setOpacity(this.element, position);
+  }
+});
+
+Effect.Move = Class.create();
+Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    var options = Object.extend({
+      x:    0,
+      y:    0,
+      mode: 'relative'
+    }, arguments[1] || {});
+    this.start(options);
+  },
+  setup: function() {
+    // Bug in Opera: Opera returns the "real" position of a static element or
+    // relative element that does not have top/left explicitly set.
+    // ==> Always set top and left for position relative elements in your stylesheets 
+    // (to 0 if you do not need them) 
+    Element.makePositioned(this.element);
+    this.originalLeft = parseFloat(Element.getStyle(this.element,'left') || '0');
+    this.originalTop  = parseFloat(Element.getStyle(this.element,'top')  || '0');
+    if(this.options.mode == 'absolute') {
+      // absolute movement, so we need to calc deltaX and deltaY
+      this.options.x = this.options.x - this.originalLeft;
+      this.options.y = this.options.y - this.originalTop;
+    }
+  },
+  update: function(position) {
+    Element.setStyle(this.element, {
+      left: this.options.x  * position + this.originalLeft + 'px',
+      top:  this.options.y  * position + this.originalTop  + 'px'
+    });
+  }
+});
+
+// for backwards compatibility
+Effect.MoveBy = function(element, toTop, toLeft) {
+  return new Effect.Move(element, 
+    Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
+};
+
+Effect.Scale = Class.create();
+Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
+  initialize: function(element, percent) {
+    this.element = $(element)
+    var options = Object.extend({
+      scaleX: true,
+      scaleY: true,
+      scaleContent: true,
+      scaleFromCenter: false,
+      scaleMode: 'box',        // 'box' or 'contents' or {} with provided values
+      scaleFrom: 100.0,
+      scaleTo:   percent
+    }, arguments[2] || {});
+    this.start(options);
+  },
+  setup: function() {
+    this.restoreAfterFinish = this.options.restoreAfterFinish || false;
+    this.elementPositioning = Element.getStyle(this.element,'position');
+    
+    this.originalStyle = {};
+    ['top','left','width','height','fontSize'].each( function(k) {
+      this.originalStyle[k] = this.element.style[k];
+    }.bind(this));
+      
+    this.originalTop  = this.element.offsetTop;
+    this.originalLeft = this.element.offsetLeft;
+    
+    var fontSize = Element.getStyle(this.element,'font-size') || '100%';
+    ['em','px','%'].each( function(fontSizeType) {
+      if(fontSize.indexOf(fontSizeType)>0) {
+        this.fontSize     = parseFloat(fontSize);
+        this.fontSizeType = fontSizeType;
+      }
+    }.bind(this));
+    
+    this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
+    
+    this.dims = null;
+    if(this.options.scaleMode=='box')
+      this.dims = [this.element.offsetHeight, this.element.offsetWidth];
+    if(/^content/.test(this.options.scaleMode))
+      this.dims = [this.element.scrollHeight, this.element.scrollWidth];
+    if(!this.dims)
+      this.dims = [this.options.scaleMode.originalHeight,
+                   this.options.scaleMode.originalWidth];
+  },
+  update: function(position) {
+    var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
+    if(this.options.scaleContent && this.fontSize)
+      Element.setStyle(this.element, {fontSize: this.fontSize * currentScale + this.fontSizeType });
+    this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
+  },
+  finish: function(position) {
+    if (this.restoreAfterFinish) Element.setStyle(this.element, this.originalStyle);
+  },
+  setDimensions: function(height, width) {
+    var d = {};
+    if(this.options.scaleX) d.width = width + 'px';
+    if(this.options.scaleY) d.height = height + 'px';
+    if(this.options.scaleFromCenter) {
+      var topd  = (height - this.dims[0])/2;
+      var leftd = (width  - this.dims[1])/2;
+      if(this.elementPositioning == 'absolute') {
+        if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
+        if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
+      } else {
+        if(this.options.scaleY) d.top = -topd + 'px';
+        if(this.options.scaleX) d.left = -leftd + 'px';
+      }
+    }
+    Element.setStyle(this.element, d);
+  }
+});
+
+Effect.Highlight = Class.create();
+Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
+    this.start(options);
+  },
+  setup: function() {
+    // Prevent executing on elements not in the layout flow
+    if(Element.getStyle(this.element, 'display')=='none') { this.cancel(); return; }
+    // Disable background image during the effect
+    this.oldStyle = {
+      backgroundImage: Element.getStyle(this.element, 'background-image') };
+    Element.setStyle(this.element, {backgroundImage: 'none'});
+    if(!this.options.endcolor)
+      this.options.endcolor = Element.getStyle(this.element, 'background-color').parseColor('#ffffff');
+    if(!this.options.restorecolor)
+      this.options.restorecolor = Element.getStyle(this.element, 'background-color');
+    // init color calculations
+    this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
+    this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
+  },
+  update: function(position) {
+    Element.setStyle(this.element,{backgroundColor: $R(0,2).inject('#',function(m,v,i){
+      return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
+  },
+  finish: function() {
+    Element.setStyle(this.element, Object.extend(this.oldStyle, {
+      backgroundColor: this.options.restorecolor
+    }));
+  }
+});
+
+Effect.ScrollTo = Class.create();
+Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    this.start(arguments[1] || {});
+  },
+  setup: function() {
+    Position.prepare();
+    var offsets = Position.cumulativeOffset(this.element);
+    if(this.options.offset) offsets[1] += this.options.offset;
+    var max = window.innerHeight ? 
+      window.height - window.innerHeight :
+      document.body.scrollHeight - 
+        (document.documentElement.clientHeight ? 
+          document.documentElement.clientHeight : document.body.clientHeight);
+    this.scrollStart = Position.deltaY;
+    this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
+  },
+  update: function(position) {
+    Position.prepare();
+    window.scrollTo(Position.deltaX, 
+      this.scrollStart + (position*this.delta));
+  }
+});
+
+/* ------------- combination effects ------------- */
+
+Effect.Fade = function(element) {
+  var oldOpacity = Element.getInlineOpacity(element);
+  var options = Object.extend({
+  from: Element.getOpacity(element) || 1.0,
+  to:   0.0,
+  afterFinishInternal: function(effect) { with(Element) { 
+    if(effect.options.to!=0) return;
+    hide(effect.element);
+    setStyle(effect.element, {opacity: oldOpacity}); }}
+  }, arguments[1] || {});
+  return new Effect.Opacity(element,options);
+}
+
+Effect.Appear = function(element) {
+  var options = Object.extend({
+  from: (Element.getStyle(element, 'display') == 'none' ? 0.0 : Element.getOpacity(element) || 0.0),
+  to:   1.0,
+  beforeSetup: function(effect) { with(Element) {
+    setOpacity(effect.element, effect.options.from);
+    show(effect.element); }}
+  }, arguments[1] || {});
+  return new Effect.Opacity(element,options);
+}
+
+Effect.Puff = function(element) {
+  element = $(element);
+  var oldStyle = { opacity: Element.getInlineOpacity(element), position: Element.getStyle(element, 'position') };
+  return new Effect.Parallel(
+   [ new Effect.Scale(element, 200, 
+      { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
+     new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
+     Object.extend({ duration: 1.0, 
+      beforeSetupInternal: function(effect) { with(Element) {
+        setStyle(effect.effects[0].element, {position: 'absolute'}); }},
+      afterFinishInternal: function(effect) { with(Element) {
+         hide(effect.effects[0].element);
+         setStyle(effect.effects[0].element, oldStyle); }}
+     }, arguments[1] || {})
+   );
+}
+
+Effect.BlindUp = function(element) {
+  element = $(element);
+  Element.makeClipping(element);
+  return new Effect.Scale(element, 0, 
+    Object.extend({ scaleContent: false, 
+      scaleX: false, 
+      restoreAfterFinish: true,
+      afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); }} 
+    }, arguments[1] || {})
+  );
+}
+
+Effect.BlindDown = function(element) {
+  element = $(element);
+  var oldHeight = Element.getStyle(element, 'height');
+  var elementDimensions = Element.getDimensions(element);
+  return new Effect.Scale(element, 100, 
+    Object.extend({ scaleContent: false, 
+      scaleX: false,
+      scaleFrom: 0,
+      scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
+      restoreAfterFinish: true,
+      afterSetup: function(effect) { with(Element) {
+        makeClipping(effect.element);
+        setStyle(effect.element, {height: '0px'});
+        show(effect.element); 
+      }},  
+      afterFinishInternal: function(effect) { with(Element) {
+        undoClipping(effect.element);
+        setStyle(effect.element, {height: oldHeight});
+      }}
+    }, arguments[1] || {})
+  );
+}
+
+Effect.SwitchOff = function(element) {
+  element = $(element);
+  var oldOpacity = Element.getInlineOpacity(element);
+  return new Effect.Appear(element, { 
+    duration: 0.4,
+    from: 0,
+    transition: Effect.Transitions.flicker,
+    afterFinishInternal: function(effect) {
+      new Effect.Scale(effect.element, 1, { 
+        duration: 0.3, scaleFromCenter: true,
+        scaleX: false, scaleContent: false, restoreAfterFinish: true,
+        beforeSetup: function(effect) { with(Element) {
+          [makePositioned,makeClipping].call(effect.element);
+        }},
+        afterFinishInternal: function(effect) { with(Element) {
+          [hide,undoClipping,undoPositioned].call(effect.element);
+          setStyle(effect.element, {opacity: oldOpacity});
+        }}
+      })
+    }
+  });
+}
+
+Effect.DropOut = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: Element.getStyle(element, 'top'),
+    left: Element.getStyle(element, 'left'),
+    opacity: Element.getInlineOpacity(element) };
+  return new Effect.Parallel(
+    [ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
+      new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
+    Object.extend(
+      { duration: 0.5,
+        beforeSetup: function(effect) { with(Element) {
+          makePositioned(effect.effects[0].element); }},
+        afterFinishInternal: function(effect) { with(Element) {
+          [hide, undoPositioned].call(effect.effects[0].element);
+          setStyle(effect.effects[0].element, oldStyle); }} 
+      }, arguments[1] || {}));
+}
+
+Effect.Shake = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: Element.getStyle(element, 'top'),
+    left: Element.getStyle(element, 'left') };
+	  return new Effect.Move(element, 
+	    { x:  20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) { with(Element) {
+        undoPositioned(effect.element);
+        setStyle(effect.element, oldStyle);
+  }}}) }}) }}) }}) }}) }});
+}
+
+Effect.SlideDown = function(element) {
+  element = $(element);
+  Element.cleanWhitespace(element);
+  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
+  var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+  var elementDimensions = Element.getDimensions(element);
+  return new Effect.Scale(element, 100, Object.extend({ 
+    scaleContent: false, 
+    scaleX: false, 
+    scaleFrom: 0,
+    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
+    restoreAfterFinish: true,
+    afterSetup: function(effect) { with(Element) {
+      makePositioned(effect.element);
+      makePositioned(effect.element.firstChild);
+      if(window.opera) setStyle(effect.element, {top: ''});
+      makeClipping(effect.element);
+      setStyle(effect.element, {height: '0px'});
+      show(element); }},
+    afterUpdateInternal: function(effect) { with(Element) {
+      setStyle(effect.element.firstChild, {bottom:
+        (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+    afterFinishInternal: function(effect) { with(Element) {
+      undoClipping(effect.element); 
+      undoPositioned(effect.element.firstChild);
+      undoPositioned(effect.element);
+      setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
+    }, arguments[1] || {})
+  );
+}
+  
+Effect.SlideUp = function(element) {
+  element = $(element);
+  Element.cleanWhitespace(element);
+  var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+  return new Effect.Scale(element, 0, 
+   Object.extend({ scaleContent: false, 
+    scaleX: false, 
+    scaleMode: 'box',
+    scaleFrom: 100,
+    restoreAfterFinish: true,
+    beforeStartInternal: function(effect) { with(Element) {
+      makePositioned(effect.element);
+      makePositioned(effect.element.firstChild);
+      if(window.opera) setStyle(effect.element, {top: ''});
+      makeClipping(effect.element);
+      show(element); }},  
+    afterUpdateInternal: function(effect) { with(Element) {
+      setStyle(effect.element.firstChild, {bottom:
+        (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+    afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); 
+        undoPositioned(effect.element.firstChild);
+        undoPositioned(effect.element);
+        setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
+   }, arguments[1] || {})
+  );
+}
+
+// Bug in opera makes the TD containing this element expand for a instance after finish 
+Effect.Squish = function(element) {
+  return new Effect.Scale(element, window.opera ? 1 : 0, 
+    { restoreAfterFinish: true,
+      beforeSetup: function(effect) { with(Element) {
+        makeClipping(effect.element); }},  
+      afterFinishInternal: function(effect) { with(Element) {
+        hide(effect.element); 
+        undoClipping(effect.element); }}
+  });
+}
+
+Effect.Grow = function(element) {
+  element = $(element);
+  var options = Object.extend({
+    direction: 'center',
+    moveTransistion: Effect.Transitions.sinoidal,
+    scaleTransition: Effect.Transitions.sinoidal,
+    opacityTransition: Effect.Transitions.full
+  }, arguments[1] || {});
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    height: element.style.height,
+    width: element.style.width,
+    opacity: Element.getInlineOpacity(element) };
+
+  var dims = Element.getDimensions(element);    
+  var initialMoveX, initialMoveY;
+  var moveX, moveY;
+  
+  switch (options.direction) {
+    case 'top-left':
+      initialMoveX = initialMoveY = moveX = moveY = 0; 
+      break;
+    case 'top-right':
+      initialMoveX = dims.width;
+      initialMoveY = moveY = 0;
+      moveX = -dims.width;
+      break;
+    case 'bottom-left':
+      initialMoveX = moveX = 0;
+      initialMoveY = dims.height;
+      moveY = -dims.height;
+      break;
+    case 'bottom-right':
+      initialMoveX = dims.width;
+      initialMoveY = dims.height;
+      moveX = -dims.width;
+      moveY = -dims.height;
+      break;
+    case 'center':
+      initialMoveX = dims.width / 2;
+      initialMoveY = dims.height / 2;
+      moveX = -dims.width / 2;
+      moveY = -dims.height / 2;
+      break;
+  }
+  
+  return new Effect.Move(element, {
+    x: initialMoveX,
+    y: initialMoveY,
+    duration: 0.01, 
+    beforeSetup: function(effect) { with(Element) {
+      hide(effect.element);
+      makeClipping(effect.element);
+      makePositioned(effect.element);
+    }},
+    afterFinishInternal: function(effect) {
+      new Effect.Parallel(
+        [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
+          new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
+          new Effect.Scale(effect.element, 100, {
+            scaleMode: { originalHeight: dims.height, originalWidth: dims.width }, 
+            sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
+        ], Object.extend({
+             beforeSetup: function(effect) { with(Element) {
+               setStyle(effect.effects[0].element, {height: '0px'});
+               show(effect.effects[0].element); }},
+             afterFinishInternal: function(effect) { with(Element) {
+               [undoClipping, undoPositioned].call(effect.effects[0].element); 
+               setStyle(effect.effects[0].element, oldStyle); }}
+           }, options)
+      )
+    }
+  });
+}
+
+Effect.Shrink = function(element) {
+  element = $(element);
+  var options = Object.extend({
+    direction: 'center',
+    moveTransistion: Effect.Transitions.sinoidal,
+    scaleTransition: Effect.Transitions.sinoidal,
+    opacityTransition: Effect.Transitions.none
+  }, arguments[1] || {});
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    height: element.style.height,
+    width: element.style.width,
+    opacity: Element.getInlineOpacity(element) };
+
+  var dims = Element.getDimensions(element);
+  var moveX, moveY;
+  
+  switch (options.direction) {
+    case 'top-left':
+      moveX = moveY = 0;
+      break;
+    case 'top-right':
+      moveX = dims.width;
+      moveY = 0;
+      break;
+    case 'bottom-left':
+      moveX = 0;
+      moveY = dims.height;
+      break;
+    case 'bottom-right':
+      moveX = dims.width;
+      moveY = dims.height;
+      break;
+    case 'center':  
+      moveX = dims.width / 2;
+      moveY = dims.height / 2;
+      break;
+  }
+  
+  return new Effect.Parallel(
+    [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
+      new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
+      new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
+    ], Object.extend({            
+         beforeStartInternal: function(effect) { with(Element) {
+           [makePositioned, makeClipping].call(effect.effects[0].element) }},
+         afterFinishInternal: function(effect) { with(Element) {
+           [hide, undoClipping, undoPositioned].call(effect.effects[0].element);
+           setStyle(effect.effects[0].element, oldStyle); }}
+       }, options)
+  );
+}
+
+Effect.Pulsate = function(element) {
+  element = $(element);
+  var options    = arguments[1] || {};
+  var oldOpacity = Element.getInlineOpacity(element);
+  var transition = options.transition || Effect.Transitions.sinoidal;
+  var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };
+  reverser.bind(transition);
+  return new Effect.Opacity(element, 
+    Object.extend(Object.extend({  duration: 3.0, from: 0,
+      afterFinishInternal: function(effect) { Element.setStyle(effect.element, {opacity: oldOpacity}); }
+    }, options), {transition: reverser}));
+}
+
+Effect.Fold = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    width: element.style.width,
+    height: element.style.height };
+  Element.makeClipping(element);
+  return new Effect.Scale(element, 5, Object.extend({   
+    scaleContent: false,
+    scaleX: false,
+    afterFinishInternal: function(effect) {
+    new Effect.Scale(element, 1, { 
+      scaleContent: false, 
+      scaleY: false,
+      afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); 
+        setStyle(effect.element, oldStyle);
+      }} });
+  }}, arguments[1] || {}));
+}

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/lightbox.css

@@ -0,0 +1,80 @@
+#lightbox{
+	position: absolute;
+	left: 0;
+	width: 100%;
+	z-index: 100;
+	text-align: center;
+	line-height: 0;
+	}
+
+#lightbox a img{ border: none; }
+
+#outerImageContainer{
+	position: relative;
+	background-color: #666;
+	width: 250px;
+	height: 250px;
+	margin: 0 auto;
+	}
+
+#imageContainer{
+	padding: 6px;
+	}
+
+#loading{
+	position: absolute;
+	top: 40%;
+	left: 0%;
+	height: 25%;
+	width: 100%;
+	text-align: center;
+	line-height: 0;
+	}
+#hoverNav{
+	position: absolute;
+	top: 0;
+	left: 0;
+	height: 100%;
+	width: 100%;
+	z-index: 10;
+	}
+#imageContainer>#hoverNav{ left: 0;}
+#hoverNav a{ outline: none;}
+
+#prevLink, #nextLink{
+	width: 49%;
+	height: 100%;
+	background: transparent url(blank.gif) no-repeat; /* Trick IE into showing hover */
+	display: block;
+	}
+#prevLink { left: 0; float: left;}
+#nextLink { right: 0; float: right;}
+#prevLink:hover, #prevLink:visited:hover { background: url(prevlabel.gif) left 15% no-repeat; }
+#nextLink:hover, #nextLink:visited:hover { background: url(nextlabel.gif) right 15% no-repeat; }
+
+
+#imageDataContainer{
+	font-size: 11px;
+         color: #fff;
+	background-color: #666;
+	margin: 0 auto;
+	line-height: 1.4em;
+	overflow: auto;
+	width: 100%
+	}
+
+#imageData{	padding:0 10px; color: #fff; }
+#imageData #imageDetails{ width: 70%; float: left; text-align: left; color: #fff; }
+#imageData #caption{ font-weight: bold;	}
+#imageData #numberDisplay{ display: block; clear: left; padding-bottom: 1.0em;	}
+#imageData #bottomNavClose{ width: 66px; float: right;  padding-bottom: 0.4em;	}
+
+#overlay{
+	position: absolute;
+	top: 0;
+	left: 0;
+	z-index: 90;
+	width: 100%;
+	height: 500px;
+	background-color: #fff;
+	}

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/lightbox.js

@@ -0,0 +1,758 @@
+
+
+//
+//	Configuration
+//
+var fileLoadingImage = "loading.gif";
+var fileBottomNavCloseImage = "closelabel.gif";
+
+var overlayOpacity = 0.1;	// controls transparency of shadow overlay
+
+var animate = true;			// toggles resizing animations
+var resizeSpeed = 7;		// controls the speed of the image resizing animations (1=slowest and 10=fastest)
+
+var borderSize = 6;		//if you adjust the padding in the CSS, you will need to update this variable
+
+// -----------------------------------------------------------------------------------
+
+//
+//	Global Variables
+//
+var imageArray = new Array;
+var activeImage;
+
+if(animate == true){
+	overlayDuration = 0.2;	// shadow fade in/out duration
+	if(resizeSpeed > 10){ resizeSpeed = 10;}
+	if(resizeSpeed < 1){ resizeSpeed = 1;}
+	resizeDuration = (11 - resizeSpeed) * 0.15;
+} else {
+	overlayDuration = 0;
+	resizeDuration = 0;
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+//	Additional methods for Element added by SU, Couloir
+//	- further additions by Lokesh Dhakar (huddletogether.com)
+//
+Object.extend(Element, {
+	getWidth: function(element) {
+	   	element = $(element);
+	   	return element.offsetWidth;
+	},
+	setWidth: function(element,w) {
+	   	element = $(element);
+    	element.style.width = w +"px";
+	},
+	setHeight: function(element,h) {
+   		element = $(element);
+    	element.style.height = h +"px";
+	},
+	setTop: function(element,t) {
+	   	element = $(element);
+    	element.style.top = t +"px";
+	},
+	setLeft: function(element,l) {
+	   	element = $(element);
+    	element.style.left = l +"px";
+	},
+	setSrc: function(element,src) {
+    	element = $(element);
+    	element.src = src;
+	},
+	setHref: function(element,href) {
+    	element = $(element);
+    	element.href = href;
+	},
+	setInnerHTML: function(element,content) {
+		element = $(element);
+		element.innerHTML = content;
+	}
+});
+
+// -----------------------------------------------------------------------------------
+
+//
+//	Extending built-in Array object
+//	- array.removeDuplicates()
+//	- array.empty()
+//
+Array.prototype.removeDuplicates = function () {
+    for(i = 0; i < this.length; i++){
+        for(j = this.length-1; j>i; j--){
+            if(this[i][0] == this[j][0]){
+                this.splice(j,1);
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------------
+
+Array.prototype.empty = function () {
+	for(i = 0; i <= this.length; i++){
+		this.shift();
+	}
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+//	Lightbox Class Declaration
+//	- initialize()
+//	- start()
+//	- changeImage()
+//	- resizeImageContainer()
+//	- showImage()
+//	- updateDetails()
+//	- updateNav()
+//	- enableKeyboardNav()
+//	- disableKeyboardNav()
+//	- keyboardNavAction()
+//	- preloadNeighborImages()
+//	- end()
+//
+//	Structuring of code inspired by Scott Upton (http://www.uptonic.com/)
+//
+var Lightbox = Class.create();
+
+Lightbox.prototype = {
+
+	// initialize()
+	// Constructor runs on completion of the DOM loading. Calls updateImageList and then
+	// the function inserts html at the bottom of the page which is used to display the shadow
+	// overlay and the image container.
+	//
+	initialize: function() {
+
+		this.updateImageList();
+
+		// Code inserts html at the bottom of the page that looks similar to this:
+		//
+		//	<div id="overlay"></div>
+		//	<div id="lightbox">
+		//		<div id="outerImageContainer">
+		//			<div id="imageContainer">
+		//				<img id="lightboxImage">
+		//				<div style="" id="hoverNav">
+		//					<a href="#" id="prevLink"></a>
+		//					<a href="#" id="nextLink"></a>
+		//				</div>
+		//				<div id="loading">
+		//					<a href="#" id="loadingLink">
+		//						<img src="images/loading.gif">
+		//					</a>
+		//				</div>
+		//			</div>
+		//		</div>
+		//		<div id="imageDataContainer">
+		//			<div id="imageData">
+		//				<div id="imageDetails">
+		//					<span id="caption"></span>
+		//					<span id="numberDisplay"></span>
+		//				</div>
+		//				<div id="bottomNav">
+		//					<a href="#" id="bottomNavClose">
+		//						<img src="images/close.gif">
+		//					</a>
+		//				</div>
+		//			</div>
+		//		</div>
+		//	</div>
+
+
+		var objBody = document.getElementsByTagName("body").item(0);
+
+		var objOverlay = document.createElement("div");
+		objOverlay.setAttribute('id','overlay');
+		objOverlay.style.display = 'none';
+		objOverlay.onclick = function() { myLightbox.end(); }
+		objBody.appendChild(objOverlay);
+
+		var objLightbox = document.createElement("div");
+		objLightbox.setAttribute('id','lightbox');
+		objLightbox.style.display = 'none';
+		objLightbox.onclick = function(e) {	// close Lightbox is user clicks shadow overlay
+			if (!e) var e = window.event;
+			var clickObj = Event.element(e).id;
+			if ( clickObj == 'lightbox') {
+				myLightbox.end();
+			}
+		};
+		objBody.appendChild(objLightbox);
+
+		var objOuterImageContainer = document.createElement("div");
+		objOuterImageContainer.setAttribute('id','outerImageContainer');
+		objLightbox.appendChild(objOuterImageContainer);
+
+		// When Lightbox starts it will resize itself from 250 by 250 to the current image dimension.
+		// If animations are turned off, it will be hidden as to prevent a flicker of a
+		// white 250 by 250 box.
+		if(animate){
+			Element.setWidth('outerImageContainer', 250);
+			Element.setHeight('outerImageContainer', 250);
+		} else {
+			Element.setWidth('outerImageContainer', 1);
+			Element.setHeight('outerImageContainer', 1);
+		}
+
+		var objImageContainer = document.createElement("div");
+		objImageContainer.setAttribute('id','imageContainer');
+		objOuterImageContainer.appendChild(objImageContainer);
+
+		var objLightboxImage = document.createElement("img");
+		objLightboxImage.setAttribute('id','lightboxImage');
+		objImageContainer.appendChild(objLightboxImage);
+
+		var objHoverNav = document.createElement("div");
+		objHoverNav.setAttribute('id','hoverNav');
+		objImageContainer.appendChild(objHoverNav);
+
+		var objPrevLink = document.createElement("a");
+		objPrevLink.setAttribute('id','prevLink');
+		objPrevLink.setAttribute('href','#');
+		objHoverNav.appendChild(objPrevLink);
+
+		var objNextLink = document.createElement("a");
+		objNextLink.setAttribute('id','nextLink');
+		objNextLink.setAttribute('href','#');
+		objHoverNav.appendChild(objNextLink);
+
+		var objLoading = document.createElement("div");
+		objLoading.setAttribute('id','loading');
+		objImageContainer.appendChild(objLoading);
+
+		var objLoadingLink = document.createElement("a");
+		objLoadingLink.setAttribute('id','loadingLink');
+		objLoadingLink.setAttribute('href','#');
+		objLoadingLink.onclick = function() { myLightbox.end(); return false; }
+		objLoading.appendChild(objLoadingLink);
+
+		var objLoadingImage = document.createElement("img");
+		objLoadingImage.setAttribute('src', fileLoadingImage);
+		objLoadingLink.appendChild(objLoadingImage);
+
+		var objImageDataContainer = document.createElement("div");
+		objImageDataContainer.setAttribute('id','imageDataContainer');
+		objLightbox.appendChild(objImageDataContainer);
+
+		var objImageData = document.createElement("div");
+		objImageData.setAttribute('id','imageData');
+		objImageDataContainer.appendChild(objImageData);
+
+		var objImageDetails = document.createElement("div");
+		objImageDetails.setAttribute('id','imageDetails');
+		objImageData.appendChild(objImageDetails);
+
+		var objCaption = document.createElement("span");
+		objCaption.setAttribute('id','caption');
+		objImageDetails.appendChild(objCaption);
+
+		var objNumberDisplay = document.createElement("span");
+		objNumberDisplay.setAttribute('id','numberDisplay');
+		objImageDetails.appendChild(objNumberDisplay);
+
+		var objBottomNav = document.createElement("div");
+		objBottomNav.setAttribute('id','bottomNav');
+		objImageData.appendChild(objBottomNav);
+
+		var objBottomNavCloseLink = document.createElement("a");
+		objBottomNavCloseLink.setAttribute('id','bottomNavClose');
+		objBottomNavCloseLink.setAttribute('href','#');
+		objBottomNavCloseLink.onclick = function() { myLightbox.end(); return false; }
+		objBottomNav.appendChild(objBottomNavCloseLink);
+
+		var objBottomNavCloseImage = document.createElement("img");
+		objBottomNavCloseImage.setAttribute('src', fileBottomNavCloseImage);
+		objBottomNavCloseLink.appendChild(objBottomNavCloseImage);
+	},
+
+
+	//
+	// updateImageList()
+	// Loops through anchor tags looking for 'lightbox' references and applies onclick
+	// events to appropriate links. You can rerun after dynamically adding images w/ajax.
+	//
+	updateImageList: function() {
+		if (!document.getElementsByTagName){ return; }
+		var anchors = document.getElementsByTagName('a');
+		var areas = document.getElementsByTagName('area');
+
+		// loop through all anchor tags
+		for (var i=0; i<anchors.length; i++){
+			var anchor = anchors[i];
+
+			var relAttribute = String(anchor.getAttribute('rel'));
+
+			// use the string.match() method to catch 'lightbox' references in the rel attribute
+			if (anchor.getAttribute('href') && (relAttribute.toLowerCase().match('lightbox'))){
+				anchor.onclick = function () {myLightbox.start(this); return false;}
+			}
+		}
+
+		// loop through all area tags
+		// todo: combine anchor & area tag loops
+		for (var i=0; i< areas.length; i++){
+			var area = areas[i];
+
+			var relAttribute = String(area.getAttribute('rel'));
+
+			// use the string.match() method to catch 'lightbox' references in the rel attribute
+			if (area.getAttribute('href') && (relAttribute.toLowerCase().match('lightbox'))){
+				area.onclick = function () {myLightbox.start(this); return false;}
+			}
+		}
+	},
+
+
+	//
+	//	start()
+	//	Display overlay and lightbox. If image is part of a set, add siblings to imageArray.
+	//
+	start: function(imageLink) {
+
+		hideSelectBoxes();
+		hideFlash();
+
+		// stretch overlay to fill page and fade in
+		var arrayPageSize = getPageSize();
+		Element.setWidth('overlay', arrayPageSize[0]);
+		Element.setHeight('overlay', arrayPageSize[1]);
+
+		new Effect.Appear('overlay', { duration: overlayDuration, from: 0.0, to: overlayOpacity });
+
+		imageArray = [];
+		imageNum = 0;
+
+		if (!document.getElementsByTagName){ return; }
+		var anchors = document.getElementsByTagName( imageLink.tagName);
+
+		// if image is NOT part of a set..
+		if((imageLink.getAttribute('rel') == 'lightbox')){
+			// add single image to imageArray
+			imageArray.push(new Array(imageLink.getAttribute('href'), imageLink.getAttribute('title')));
+		} else {
+		// if image is part of a set..
+
+			// loop through anchors, find other images in set, and add them to imageArray
+			for (var i=0; i<anchors.length; i++){
+				var anchor = anchors[i];
+				if (anchor.getAttribute('href') && (anchor.getAttribute('rel') == imageLink.getAttribute('rel'))){
+					imageArray.push(new Array(anchor.getAttribute('href'), anchor.getAttribute('title')));
+				}
+			}
+			imageArray.removeDuplicates();
+			while(imageArray[imageNum][0] != imageLink.getAttribute('href')) { imageNum++;}
+		}
+
+		// calculate top and left offset for the lightbox
+		var arrayPageScroll = getPageScroll();
+		var lightboxTop = arrayPageScroll[1] + (arrayPageSize[3] / 20);
+		var lightboxLeft = arrayPageScroll[0];
+		Element.setTop('lightbox', lightboxTop);
+		Element.setLeft('lightbox', lightboxLeft);
+
+		Element.show('lightbox');
+
+		this.changeImage(imageNum);
+	},
+
+	//
+	//	changeImage()
+	//	Hide most elements and preload image in preparation for resizing image container.
+	//
+	changeImage: function(imageNum) {
+
+		activeImage = imageNum;	// update global var
+
+		// hide elements during transition
+		if(animate){ Element.show('loading');}
+		Element.hide('lightboxImage');
+		Element.hide('hoverNav');
+		Element.hide('prevLink');
+		Element.hide('nextLink');
+		Element.hide('imageDataContainer');
+		Element.hide('numberDisplay');
+
+		imgPreloader = new Image();
+
+		// once image is preloaded, resize image container
+		imgPreloader.onload=function(){
+			Element.setSrc('lightboxImage', imageArray[activeImage][0]);
+			myLightbox.resizeImageContainer(imgPreloader.width, imgPreloader.height);
+
+			imgPreloader.onload=function(){};	//	clear onLoad, IE behaves irratically with animated gifs otherwise
+		}
+		imgPreloader.src = imageArray[activeImage][0];
+	},
+
+	//
+	//	resizeImageContainer()
+	//
+	resizeImageContainer: function( imgWidth, imgHeight) {
+
+		// get curren width and height
+		this.widthCurrent = Element.getWidth('outerImageContainer');
+		this.heightCurrent = Element.getHeight('outerImageContainer');
+
+		// get new width and height
+		var widthNew = (imgWidth  + (borderSize * 2));
+		var heightNew = (imgHeight  + (borderSize * 2));
+
+		// scalars based on change from old to new
+		this.xScale = ( widthNew / this.widthCurrent) * 100;
+		this.yScale = ( heightNew / this.heightCurrent) * 100;
+
+		// calculate size difference between new and old image, and resize if necessary
+		wDiff = this.widthCurrent - widthNew;
+		hDiff = this.heightCurrent - heightNew;
+
+		if(!( hDiff == 0)){ new Effect.Scale('outerImageContainer', this.yScale, {scaleX: false, duration: resizeDuration, queue: 'front'}); }
+		if(!( wDiff == 0)){ new Effect.Scale('outerImageContainer', this.xScale, {scaleY: false, delay: resizeDuration, duration: resizeDuration}); }
+
+		// if new and old image are same size and no scaling transition is necessary,
+		// do a quick pause to prevent image flicker.
+		if((hDiff == 0) && (wDiff == 0)){
+			if (navigator.appVersion.indexOf("MSIE")!=-1){ pause(250); } else { pause(100);}
+		}
+
+		Element.setHeight('prevLink', imgHeight);
+		Element.setHeight('nextLink', imgHeight);
+		Element.setWidth( 'imageDataContainer', widthNew);
+
+		this.showImage();
+	},
+
+	//
+	//	showImage()
+	//	Display image and begin preloading neighbors.
+	//
+	showImage: function(){
+		Element.hide('loading');
+		new Effect.Appear('lightboxImage', { duration: resizeDuration, queue: 'end', afterFinish: function(){	myLightbox.updateDetails(); } });
+		this.preloadNeighborImages();
+	},
+
+	//
+	//	updateDetails()
+	//	Display caption, image number, and bottom nav.
+	//
+	updateDetails: function() {
+
+		// if caption is not null
+		if(imageArray[activeImage][1]){
+			Element.show('caption');
+			Element.setInnerHTML( 'caption', imageArray[activeImage][1]);
+		}
+
+		// if image is part of set display 'Image x of x'
+		if(imageArray.length > 1){
+			Element.show('numberDisplay');
+			Element.setInnerHTML( 'numberDisplay', "Bild " + eval(activeImage + 1) + " von " + imageArray.length);
+		}
+
+		new Effect.Parallel(
+			[ new Effect.SlideDown( 'imageDataContainer', { sync: true, duration: resizeDuration, from: 0.0, to: 1.0 }),
+			  new Effect.Appear('imageDataContainer', { sync: true, duration: resizeDuration }) ],
+			{ duration: resizeDuration, afterFinish: function() {
+				// update overlay size and update nav
+				var arrayPageSize = getPageSize();
+				Element.setHeight('overlay', arrayPageSize[1]);
+				myLightbox.updateNav();
+				}
+			}
+		);
+	},
+
+	//
+	//	updateNav()
+	//	Display appropriate previous and next hover navigation.
+	//
+	updateNav: function() {
+
+		Element.show('hoverNav');
+
+		// if not first image in set, display prev image button
+		if(activeImage != 0){
+			Element.show('prevLink');
+			document.getElementById('prevLink').onclick = function() {
+				myLightbox.changeImage(activeImage - 1); return false;
+			}
+		}
+
+		// if not last image in set, display next image button
+		if(activeImage != (imageArray.length - 1)){
+			Element.show('nextLink');
+			document.getElementById('nextLink').onclick = function() {
+				myLightbox.changeImage(activeImage + 1); return false;
+			}
+		}
+
+		this.enableKeyboardNav();
+	},
+
+	//
+	//	enableKeyboardNav()
+	//
+	enableKeyboardNav: function() {
+		document.onkeydown = this.keyboardAction;
+	},
+
+	//
+	//	disableKeyboardNav()
+	//
+	disableKeyboardNav: function() {
+		document.onkeydown = '';
+	},
+
+	//
+	//	keyboardAction()
+	//
+	keyboardAction: function(e) {
+		if (e == null) { // ie
+			keycode = event.keyCode;
+			escapeKey = 27;
+		} else { // mozilla
+			keycode = e.keyCode;
+			escapeKey = e.DOM_VK_ESCAPE;
+		}
+
+		key = String.fromCharCode(keycode).toLowerCase();
+
+		if((key == 'x') || (key == 'o') || (key == 'c') || (keycode == escapeKey)){	// close lightbox
+			myLightbox.end();
+		} else if((key == 'p') || (keycode == 37)){	// display previous image
+			if(activeImage != 0){
+				myLightbox.disableKeyboardNav();
+				myLightbox.changeImage(activeImage - 1);
+			}
+		} else if((key == 'n') || (keycode == 39)){	// display next image
+			if(activeImage != (imageArray.length - 1)){
+				myLightbox.disableKeyboardNav();
+				myLightbox.changeImage(activeImage + 1);
+			}
+		}
+
+	},
+
+	//
+	//	preloadNeighborImages()
+	//	Preload previous and next images.
+	//
+	preloadNeighborImages: function(){
+
+		if((imageArray.length - 1) > activeImage){
+			preloadNextImage = new Image();
+			preloadNextImage.src = imageArray[activeImage + 1][0];
+		}
+		if(activeImage > 0){
+			preloadPrevImage = new Image();
+			preloadPrevImage.src = imageArray[activeImage - 1][0];
+		}
+
+	},
+
+	//
+	//	end()
+	//
+	end: function() {
+		this.disableKeyboardNav();
+		Element.hide('lightbox');
+		new Effect.Fade('overlay', { duration: overlayDuration});
+		showSelectBoxes();
+		showFlash();
+	}
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+// getPageScroll()
+// Returns array with x,y page scroll values.
+// Core code from - quirksmode.com
+//
+function getPageScroll(){
+
+	var xScroll, yScroll;
+
+	if (self.pageYOffset) {
+		yScroll = self.pageYOffset;
+		xScroll = self.pageXOffset;
+	} else if (document.documentElement && document.documentElement.scrollTop){	 // Explorer 6 Strict
+		yScroll = document.documentElement.scrollTop;
+		xScroll = document.documentElement.scrollLeft;
+	} else if (document.body) {// all other Explorers
+		yScroll = document.body.scrollTop;
+		xScroll = document.body.scrollLeft;
+	}
+
+	arrayPageScroll = new Array(xScroll,yScroll)
+	return arrayPageScroll;
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+// getPageSize()
+// Returns array with page width, height and window width, height
+// Core code from - quirksmode.com
+// Edit for Firefox by pHaez
+//
+function getPageSize(){
+
+	var xScroll, yScroll;
+
+	if (window.innerHeight && window.scrollMaxY) {
+		xScroll = window.innerWidth + window.scrollMaxX;
+		yScroll = window.innerHeight + window.scrollMaxY;
+	} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
+		xScroll = document.body.scrollWidth;
+		yScroll = document.body.scrollHeight;
+	} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
+		xScroll = document.body.offsetWidth;
+		yScroll = document.body.offsetHeight;
+	}
+
+	var windowWidth, windowHeight;
+
+//	console.log(self.innerWidth);
+//	console.log(document.documentElement.clientWidth);
+
+	if (self.innerHeight) {	// all except Explorer
+		if(document.documentElement.clientWidth){
+			windowWidth = document.documentElement.clientWidth;
+		} else {
+			windowWidth = self.innerWidth;
+		}
+		windowHeight = self.innerHeight;
+	} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
+		windowWidth = document.documentElement.clientWidth;
+		windowHeight = document.documentElement.clientHeight;
+	} else if (document.body) { // other Explorers
+		windowWidth = document.body.clientWidth;
+		windowHeight = document.body.clientHeight;
+	}
+
+	// for small pages with total height less then height of the viewport
+	if(yScroll < windowHeight){
+		pageHeight = windowHeight;
+	} else {
+		pageHeight = yScroll;
+	}
+
+//	console.log("xScroll " + xScroll)
+//	console.log("windowWidth " + windowWidth)
+
+	// for small pages with total width less then width of the viewport
+	if(xScroll < windowWidth){
+		pageWidth = xScroll;
+	} else {
+		pageWidth = windowWidth;
+	}
+//	console.log("pageWidth " + pageWidth)
+
+	arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight)
+	return arrayPageSize;
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+// getKey(key)
+// Gets keycode. If 'x' is pressed then it hides the lightbox.
+//
+function getKey(e){
+	if (e == null) { // ie
+		keycode = event.keyCode;
+	} else { // mozilla
+		keycode = e.which;
+	}
+	key = String.fromCharCode(keycode).toLowerCase();
+
+	if(key == 'x'){
+	}
+}
+
+// -----------------------------------------------------------------------------------
+
+//
+// listenKey()
+//
+function listenKey () {	document.onkeypress = getKey; }
+
+// ---------------------------------------------------
+
+function showSelectBoxes(){
+	var selects = document.getElementsByTagName("select");
+	for (i = 0; i != selects.length; i++) {
+		selects[i].style.visibility = "visible";
+	}
+}
+
+// ---------------------------------------------------
+
+function hideSelectBoxes(){
+	var selects = document.getElementsByTagName("select");
+	for (i = 0; i != selects.length; i++) {
+		selects[i].style.visibility = "hidden";
+	}
+}
+
+// ---------------------------------------------------
+
+function showFlash(){
+	var flashObjects = document.getElementsByTagName("object");
+	for (i = 0; i < flashObjects.length; i++) {
+		flashObjects[i].style.visibility = "visible";
+	}
+
+	var flashEmbeds = document.getElementsByTagName("embed");
+	for (i = 0; i < flashEmbeds.length; i++) {
+		flashEmbeds[i].style.visibility = "visible";
+	}
+}
+
+// ---------------------------------------------------
+
+function hideFlash(){
+	var flashObjects = document.getElementsByTagName("object");
+	for (i = 0; i < flashObjects.length; i++) {
+		flashObjects[i].style.visibility = "hidden";
+	}
+
+	var flashEmbeds = document.getElementsByTagName("embed");
+	for (i = 0; i < flashEmbeds.length; i++) {
+		flashEmbeds[i].style.visibility = "hidden";
+	}
+
+}
+
+
+// ---------------------------------------------------
+
+//
+// pause(numberMillis)
+// Pauses code execution for specified time. Uses busy code, not good.
+// Help from Ran Bar-On [ran2103@gmail.com]
+//
+
+function pause(ms){
+	var date = new Date();
+	curDate = null;
+	do{var curDate = new Date();}
+	while( curDate - date < ms);
+}
+/*
+function pause(numberMillis) {
+	var curently = new Date().getTime() + sender;
+	while (new Date().getTime();
+}
+*/
+// ---------------------------------------------------
+
+
+
+function initLightbox() { myLightbox = new Lightbox(); }
+Event.observe(window, 'load', initLightbox, false);

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/script1.js

@@ -0,0 +1,152 @@
+
+function t(t,a,n,p) {
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"=";}
+
+
+// 16x4 Spindeln nach Länge bestellen
+function ts(t, a ,n,l, p) {
+machen = true;
+if ( l.length != 3 )  {  alert("Bitte die Länge richtig eingeben (3 Stellen)!");machen = false;  }
+if ( l > 999 )  {  alert("Maximale Länge des Trapezgewindes ist 999 mm!");machen = false;  }
+if ( l < 100 )  {  alert("Minimale Länge des Trapezgewindes ist 100 mm!");machen = false;  }
+if (machen == true )  {
+p = 0.02; // Preis pro mm
+p = (p * l);
+p = p.toFixed(2);
+a = a + l + "c";
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"="; }
+ }
+
+
+
+
+
+// 12x3 Spindeln langes Gewinde
+function tsl1(t, a ,n,l, p) {
+machen = true;
+if ( l.length != 3 )  {  alert("Bitte die Länge richtig eingeben (3 Stellen)!");machen = false;  }
+if ( l > 900 )  {  alert("Maximale Länge des Trapezgewindes ist 900 mm!");machen = false;  }
+if ( l < 100 )  {  alert("Minimale Länge des Trapezgewindes ist 100 mm!");machen = false;  }
+if (machen == true )  {
+p = 0.015;  // Preis pro mm
+p = (p * l) + 12.14;
+p = p.toFixed(2);
+a = a + l + "c";
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"="; }
+ }
+
+// 16x4 Spindeln kurzes Gewinde
+function tsk(t, a ,n,l, p) {
+machen = true;
+if ( l.length == 3 )  {  a = "16X4TK0";  }
+if ( l.length == 4 )  {  a = "16X4TK";  }
+if ( l > 1230 )  {  alert("Maximale Länge des Trapezgewindes ist 1230 mm!");machen = false;  }
+if ( l < 100 )  {  alert("Minimale Länge des Trapezgewindes ist 100 mm!");machen = false;  }
+if (machen == true )  {
+p = 0.02;  // Preis pro mm
+p = (p * l) + 13.14;
+p = p.toFixed(2);
+if ( l < 1100 )  { a = a + l + "c"; }
+if ( l > 1099 )  { a = a + l + "e"; }
+
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"="; }
+ }
+
+// 16x4 Spindeln langes Gewinde
+function tsl(t, a ,n,l, p) {
+machen = true;
+if ( l.length == 3 )  {  a = "16X4TL0";  }
+if ( l.length == 4 )  {  a = "16X4TL";  }
+if ( l > 1230 )  {  alert("Maximale Länge des Trapezgewindes ist 1230 mm!");machen = false;  }
+if ( l < 100 )  {  alert("Minimale Länge des Trapezgewindes ist 100 mm!");machen = false;  }
+if (machen == true )  {
+p = 0.02;  // Preis pro mm
+p = (p * l) + 13.14;
+p = p.toFixed(2);
+if ( l < 1100 )  { a = a + l + "c"; }
+if ( l > 1099 )  { a = a + l + "e"; }
+
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"="; }
+ }
+
+ // 16x4 Spindeln langes Gewinde 33mm
+function tss(t, a ,n,l, p) {
+machen = true;
+if ( l.length == 3 )  {  a = "16X4TS0";  }
+if ( l.length == 4 )  {  a = "16X4TS";  }
+if ( l > 1230 )  {  alert("Maximale Länge des Trapezgewindes ist 1230 mm!");machen = false;  }
+if ( l < 100 )  {  alert("Minimale Länge des Trapezgewindes ist 100 mm!");machen = false;  }
+if (machen == true )  {
+p = 0.02;  // Preis pro mm
+p = (p * l) + 13.14;
+p = p.toFixed(2);
+if ( l < 1100 )  { a = a + l + "c"; }
+if ( l > 1099 )  { a = a + l + "e"; }
+
+alert(+n+" Stück "+t+" "+a+" wurde in den Warenkorb gelegt! ");
+name1 = "p1r2i|"+a+"|"+t+"|"+n+"|"+p;
+document.cookie =  name1+"="; }
+ }
+
+
+function CookieSetzen (name, wert, verfall, pfad, domain, sicher) {
+
+  document.cookie =  name + "=" + escape (wert) +
+		     ((verfall) ? "; expires=" + verfall.toGMTString() : "") +
+		     ((pfad) 		? "; path=" + pfad : "") +
+		     ((domain) 	? "; domain=" + domain : "") +
+		     ((sicher) 	? "; secure=" + sicher : "");
+}
+
+
+function WegdaCookie(name, pfad, domain) {
+
+	Ehemals = new Date ();
+	Ehemals.setTime (Ehemals.getTime () - (365 * 24 * 60 * 60 * 1000));
+
+	CookieSetzen (name, "", Ehemals, pfad, domain);
+
+  }
+
+
+
+
+
+
+function agb() {
+ if (document.form.B_.value == '') alert("Ihr Warenkorb ist leer! Bitte zuerst eine Ware durch anklicken in den Warenkorb legen !");
+else
+ if (document.form.AGBs________.checked != true ) alert("Bitte zuerst AGB's bestätigen !");
+ else
+ if (document.form.email_______.value == '' ) alert("Bitte Emailadresse eingeben!");
+ else
+ if (document.form.email_______.value.indexOf('.') < 0) alert("Emailadresse ungueltig!");
+ else
+ if (document.form.email_______.value.indexOf('@') < 0) alert("Emailadresse ungueltig!");
+ else
+ if (document.form.Name________.value == '' ) alert("Bitte Ihren Namen eingeben !");
+ else
+ if (document.form.Strasse_____.value == '' ) alert("Bitte Strasse mit Nummer eingeben !");
+ else
+ if (document.form.Plz_________.value == '' ) alert("Bitte Ihre PLZ eingeben !");
+ else
+ if (document.form.Ort_________.value == '' ) alert("Bitte Ihren Ort eingeben !");
+
+
+ }
+
+
+
+function  focus1() {
+document.form.Name________.select();
+}

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/script2.js

@@ -0,0 +1,40 @@
+function get_z1()
+{
+return("Vorkasse");
+}
+function get_z2()
+{
+return("");
+}
+function get_z3()
+{
+return("");
+}
+function get_z4()
+{
+return("");
+}
+function get_p1()
+{
+return("2.45");
+}
+function get_p2()
+{
+return("");
+}
+function get_p3()
+{
+return("");
+}
+function get_p4()
+{
+return("");
+}
+function get_waehrung()
+{
+return("Euro");
+}
+function get_text1()
+{
+return("");
+}

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/script3.js

@@ -0,0 +1,480 @@
+var ursprung='';
+var sprung=0;
+var ziel='';
+felder = new Array("document.form.besteller","form.strasse","plz","ort" );
+
+function del()
+	{//WegdaCookie(document.cookie,0,0);
+	}
+
+
+
+function del_wk()
+	{
+	document.form.B_.value = "";
+//    document.cookie = "=";
+ WegdaCookie(document.cookie,0,0);
+	}
+
+
+function onload1() {
+ zahlungsarten();
+ berechne();
+                    }
+
+
+
+function zahlungsarten () {
+
+// ***************************************************************
+// Zahlungsarten eintragen ist aber nicht wichtig
+// ***************************************************************
+
+if(get_z4()!="") {
+element = new Option(get_z4(),get_p4(), false, true);
+document.form.Versand_____.options[3] = element;
+               }
+
+if(get_z3()!="") {
+element = new Option(get_z3(),get_p3(), false, true);
+document.form.Versand_____.options[2] = element;
+               }
+if(get_z2()!="") {
+element = new Option(get_z2(),get_p2(), false, true);
+document.form.Versand_____.options[1] = element;
+               }
+if(get_z1()!="") {
+element = new Option(get_z1(),get_p1(), false, true);
+document.form.Versand_____.options[0] = element;
+               }
+
+}
+
+
+
+
+
+
+
+function berechne () {
+
+anmerkung = 0;
+anmerkungg = 0;
+versand = "";
+versand = "2.45";
+versandz = 0;
+// cookie in B_ schreiben
+
+c = document.cookie;
+
+
+//if(documern.Name________.value == "debug")alert(c);
+
+px1 = 0;
+px2 = 0;
+// 1. Test ob Warenkorb brauchbar
+px1 = c.indexOf('p1r2i');
+if (px1<0)  c = "";        // Warenkorb hat keine Positionen
+
+//if(documern.Name________.value == "debug") alert(c);
+
+c = c+";";
+l = c.length;
+
+
+document.form.B_.value = "";
+
+// alert(c+"  "+l);
+// alert(l);
+
+if ( l > 7 ) {
+
+
+i = 0;
+w = true;
+pos = 0;
+len1 = 0;
+f = 0;
+position = 0;
+
+pos_gpreis = 0.0;
+pos_epreis = 0.0;
+pos_menge  = 0.0;
+spos_gpreis = " ";
+
+sum_gpreis = 0.0;
+rabatt = " ";
+sum_vpreis = 0.0;
+
+ssum_gpreis = " ";
+
+
+while( w == true) {
+
+px1  = c.indexOf('p1r2i');
+c    = c.substr(px1+6,l);         // vorne abschneiden
+
+px2 = c.indexOf(';');
+
+pos = 1;
+
+sub1 = c.substr(0,px2);           // eine Position im String
+c    = c.substr(px2+1,l);         // Position wird rausgeschnitten
+len1 = sub1.length;               // Länge Positionsstring
+
+// alert(c);
+// alert("sub1: "+sub1);
+
+// eine Position ermittelt
+
+// alert("|"+sub1+"  "+len1);
+
+ab1 = 0;
+ab2 = 0;
+ab3 = 0;
+for (f=0;f<len1;f++){ if(sub1.substr(f,1)=="|") { if(ab2!=0) ab3 = f;
+                                                  if(ab1!=0&&ab2==0) ab2 = f;
+                                                  if(ab1==0) ab1 = f;
+                                                    }
+                 } // for
+
+artikel = sub1.substr(0,ab1);
+text    = sub1.substr(ab1+1,ab2-ab1-1);
+menge   = sub1.substr(ab2+1,ab3-ab2-1);
+preis   = sub1.substr(ab3+1,len1-ab3);
+
+// wegen Mozilla !!
+pl = preis.length;
+if(preis.substr(pl-1,1)== '=')  preis = preis.substr(0,pl-1);
+
+
+pos_menge  = menge;
+pos_epreis = preis;
+pos_gpreis = pos_menge * pos_epreis;
+
+sum_gpreis = sum_gpreis + pos_gpreis;
+
+//spos_gpreis = pos_gpreis.toString();
+spos_gpreis =   pos_gpreis.toFixed(2); // 2 Nachkommastellen
+
+
+lg = spos_gpreis.length
+if (spos_gpreis.indexOf('.')== -1) spos_gpreis = spos_gpreis+".00";
+if (spos_gpreis.indexOf('.')== lg-2 ) spos_gpreis = spos_gpreis+"0";
+
+
+fixlen = 7;
+spos_gpreis = spos_gpreis.substr(0,fixlen);
+alen = spos_gpreis.length;
+text1 = "";
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text1 = text1+spos_gpreis;
+spos_gpreis = text1;
+
+apos = "0";
+position = position +1;
+apos = position;
+text1 = "";
+if (position <10 ) text1 = "0";
+text1 = text1+apos;
+apos  = text1;
+
+
+fixlen = 11;
+artikel = artikel.substr(0,fixlen);
+alen = artikel.length;
+text1 = artikel;
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+artikel = text1;
+
+
+fixlen = 30;
+text = text.substr(0,fixlen);
+alen = text.length;
+text1 = text;
+//for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text = text1;
+
+fixlen = 5;
+menge = menge.substr(0,fixlen);
+alen = menge.length;
+text1 = "";
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text1 = text1+menge;
+menge = text1;
+
+fixlen = 6;
+preis = preis.substr(0,fixlen);
+text1 = ""
+alen = preis.length;
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+if (alen == 4) text1 = " " + text1;
+text1 = text1+preis;
+preis = text1;
+
+//alert("|"+artikel);
+//alert(text);
+//alert(menge);
+//alert(preis);
+
+//b WegdaCookie(sub1,0,0);
+
+
+text1 = " "+apos+""+menge+"Stück  "+artikel+"  Preis:"+preis+"€   Summe:"+spos_gpreis+"€  "+text+"\n";
+
+
+lg = artikel.length;
+if (artikel.indexOf('a')==lg-1) if (versandz < 1)versandz = 1;
+if (artikel.indexOf('b')==lg-1) if (versandz < 2)versandz = 2;
+if (artikel.indexOf('c')==lg-1) if (versandz < 3)versandz = 3;
+if (artikel.indexOf('d')==lg-1) if (versandz < 4)versandz = 4;
+if (artikel.indexOf('e')==lg-1) if (versandz < 5)versandz = 5;
+if (artikel.indexOf('f')==lg-1) if (versandz < 6)versandz = 6;
+if (artikel.indexOf('g')==lg-1) if (versandz < 7)versandz = 7;
+if (artikel.indexOf('h')==lg-1) if (versandz < 8)versandz = 8;
+if (artikel.indexOf('x')==lg-2) anmerkung = 1;
+if (artikel.indexOf('g')==lg-1) anmerkungg = 1;
+if (artikel.indexOf('h')==lg-1) anmerkungg = 1;
+
+
+document.form.B_.value = document.form.B_.value + text1;
+
+if(c.indexOf('p1r2i') < 0 ) break;
+} // end while ----------------------------------------------------------
+
+if (versandz == 1) versand = "4.45";
+if (versandz == 2) versand = "5.95";
+if (versandz == 3) versand = "8.95";
+if (versandz == 4) versand = "9.95";
+if (versandz == 5) versand = "14.95";
+if (versandz == 6) versand = "19.95";
+if (versandz == 7) versand = "159.00";
+if (versandz == 8) versand = "159.00";
+
+gesammtpreis = sum_gpreis.toFixed(2); // 2 Nachkommastellen
+
+//if (sum_gpreis > 49.99) if (sum_gpreis < 100) sum_gpreis = sum_gpreis /100 * 97 ;
+//if (sum_gpreis > 99.99) if (sum_gpreis < 150) sum_gpreis = sum_gpreis /100 * 96 ;
+//if (sum_gpreis > 149.99) sum_gpreis = sum_gpreis /100 * 95 ;
+
+
+if (sum_gpreis > 350) if (versand == "5.95") versand = "8.95";
+if (sum_gpreis > 150) if (versand == "4.45") versand = "5.95";
+
+
+//ssum_gpreis = sum_gpreis.toString();
+
+ssum_gpreis = sum_gpreis.toFixed(2); // 2 Nachkommastellen
+
+lg = ssum_gpreis.length;
+if (ssum_gpreis.indexOf('.')== lg-1) ssum_gpreis = ssum_gpreis + ".00";
+if (ssum_gpreis.indexOf('.')== lg-2 ) ssum_gpreis = ssum_gpreis +"0";
+
+
+
+
+
+lx1 = ssum_gpreis.indexOf('.');
+ssum_gpreis = ssum_gpreis.substr(0,lx1+3);
+
+
+fixlen = 10;
+ssum_gpreis = ssum_gpreis.substr(0,fixlen);
+alen = ssum_gpreis.length;
+text1 = "";
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+
+text1 = text1+ssum_gpreis;
+ssum_gpreis = text1;
+//
+//
+text1 = "\n";
+document.form.B_.value = document.form.B_.value + text1;
+
+rabatt = " ";
+
+//if (gesammtpreis > 49.99) if (gesammtpreis < 100) rabatt = "      vom Warenwert " +gesammtpreis+" Euro wurden 3% Rabatt abgezogen!";
+//if (gesammtpreis > 99.99) if (gesammtpreis < 150) rabatt = "      vom Warenwert " +gesammtpreis+" Euro wurden 4% Rabatt abgezogen!";
+
+
+//if (gesammtpreis > 149.99) rabatt = "      vom Warenwert " +gesammtpreis+" Euro wurden 5% Rabatt abgezogen!";
+
+
+
+
+
+
+text1 = "Warenwert Summe: "+get_waehrung()+ssum_gpreis+rabatt+"\n";
+document.form.B_.value = document.form.B_.value + text1;
+//
+//
+vtext = "";
+vpreis = "";
+
+
+if (get_z1() != "") if(document.form.Versand_____.options[0].selected) vtext = get_z1();
+if (get_z2() != "") if(document.form.Versand_____.options[1].selected) vtext = get_z2();
+if (get_z3() != "") if(document.form.Versand_____.options[2].selected) vtext = get_z3();
+if (get_z4() != "") if(document.form.Versand_____.options[3].selected) vtext = get_z4();
+
+if (get_z1() != "") if(document.form.Versand_____.options[0].selected) vpreis = get_p1();
+if (get_z2() != "") if(document.form.Versand_____.options[1].selected) vpreis = get_p2();
+if (get_z3() != "") if(document.form.Versand_____.options[2].selected) vpreis = get_p3();
+if (get_z4() != "") if(document.form.Versand_____.options[3].selected) vpreis = get_p4();
+
+if (vpreis > 0 ) {
+
+if (versand > 0) vpreis = versand; //Versand wird erhöht;
+
+
+sum_vpreis = vpreis;
+
+
+sum_gpreis += (sum_vpreis * 1);
+
+fixlen = 6;
+vpreis = vpreis.substr(0,fixlen);
+alen = vpreis.length;
+text1 = "";
+//for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text1 = text1+vpreis;
+vpreis = text1;
+
+fixlen = 12;
+vtext = vtext.substr(0,fixlen);
+alen = vtext.length;
+text1 = "";
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text1 = text1+vtext;
+vtext = text1;
+
+text1 = "Versandkosten incl: "+get_waehrung()+"       "+vpreis+"\n";
+document.form.B_.value = document.form.B_.value + text1;
+
+} // Ende Berechnung der Versandkosten
+
+
+ssum_gpreis = sum_gpreis.toString();
+
+//alert(ssum_gpreis);
+
+lg = ssum_gpreis.length
+if (ssum_gpreis.indexOf('.')== -1) ssum_gpreis = ssum_gpreis + ".00";
+if (ssum_gpreis.indexOf('.')== lg-2 ) ssum_gpreis = ssum_gpreis +"0";
+
+lx1 = ssum_gpreis.indexOf('.');
+ssum_gpreis = ssum_gpreis.substr(0,lx1+3);
+
+
+fixlen = 10;
+ssum_gpreis = ssum_gpreis.substr(0,fixlen);
+alen = ssum_gpreis.length;
+text1 = "";
+for(n=0;n<fixlen-alen;n++) text1 = text1+" ";
+text1 = text1+ssum_gpreis;
+ssum_gpreis = text1;
+//
+//
+
+if (vpreis > 0 ) {
+
+text1 = "Rechnungssumme:  "+get_waehrung()+ssum_gpreis+"\n";
+document.form.B_.value = document.form.B_.value + text1;
+
+
+mwst = sum_gpreis;  // Endpreis übernehmen
+mwst = mwst/119*19;
+mwst = mwst.toFixed(2); // 2 Nachkommastellen
+
+
+text1 ="enthält  19% MwSt:  "+get_waehrung()+"      "+mwst+"\n\n";
+document.form.B_.value = document.form.B_.value + text1;
+
+if (anmerkung > 0)text1 = "Wir prüfen, ob der gewünschte Sonderposten verfügbar ist. Bestätigung erfolgt per extra Mail!\n\n";
+if (anmerkung > 0)document.form.B_.value = document.form.B_.value + text1;
+
+
+if ( versand == "159.00")text1 = "Sie brauchen das Geld für die Maschine nicht gleich überweisen. In den nächsten\n";
+if ( versand == "159.00")document.form.B_.value = document.form.B_.value + text1;
+
+if ( versand == "159.00")text1 = "Tagen erhalten Sie eine Anzahlungsrechnung, die Sie dann bitte überweisen.\n\n";
+if ( versand == "159.00")document.form.B_.value = document.form.B_.value + text1;
+
+} // end Vpreis > 0
+
+
+
+
+if (get_text1().length > 0) document.form.B_.value = document.form.B_.value + get_text1()+"\n";
+
+
+} // end if l > 7
+} // end function
+
+function CookieSetzen (name, wert, verfall, pfad, domain, sicher) {
+
+  document.cookie =  name + "=" + escape (wert) +
+		     ((verfall) ? "; expires=" + verfall.toGMTString() : "") +
+		     ((pfad) 		? "; path=" + pfad : "") +
+		     ((domain) 	? "; domain=" + domain : "") +
+		     ((sicher) 	? "; secure=" + sicher : "");
+}
+
+
+function WegdaCookie(name, pfad, domain) {
+
+	Ehemals = new Date ();
+	Ehemals.setTime (Ehemals.getTime () - (365 * 24 * 60 * 60 * 1000));
+
+	CookieSetzen (name, "", Ehemals, pfad, domain);
+
+  }
+
+
+function d(pos1)
+{
+
+npos1 = 0;
+zpos1 = 0;
+len1 = 0;
+len2 = 0;
+
+npos1 = pos1;
+
+if(document.form.Name________.value == "debug") alert(document.cookie);
+else {
+
+c = document.cookie;
+c = c+";";
+
+npos1 = 0;
+
+while (true) {
+
+px1  = c.indexOf('p1r2i');
+c    = c.substr(px1,l);         // vorne abschneiden
+px2  = c.indexOf(';');
+
+sub1 = c.substr(0,px2);           // eine Position im String
+c    = c.substr(px2+1,l);         // Position wird rausgeschnitten
+len1 = sub1.length;               // Länge Positionsstring
+
+npos1 = npos1 +1;
+if (npos1 == pos1) break;
+
+}
+
+
+// eine Position ermittelt
+// alert(sub1);
+// alert(c);
+
+alert("Position  "+pos1+" gelöscht !");
+
+WegdaCookie(sub1,0,0);
+
+
+ berechne();
+
+}
+}

RessourceGénérale/EMS/DE/CNC-Fräsmaschinen_files/scriptaculous.js

@@ -0,0 +1,26 @@
+
+
+var Scriptaculous = {
+  Version: '1.5.1',
+  require: function(libraryName) {
+    // inserting via DOM fails in Safari 2.0, so brute force approach
+    document.write('<script type="text/javascript" src="'+libraryName+'"></script>');
+  },
+  load: function() {
+    if((typeof Prototype=='undefined') ||
+      parseFloat(Prototype.Version.split(".")[0] + "." +
+                 Prototype.Version.split(".")[1]) < 1.4)
+      throw("script.aculo.us requires the Prototype JavaScript framework >= 1.4.0");
+
+    $A(document.getElementsByTagName("script")).findAll( function(s) {
+      return (s.src && s.src.match(/scriptaculous\.js(\?.*)?$/))
+    }).each( function(s) {
+      var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
+      var includes = s.src.match(/\?.*load=([a-z,]*)/);
+      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider').split(',').each(
+       function(include) { Scriptaculous.require(path+include+'.js') });
+    });
+  }
+}
+
+Scriptaculous.load();

RessourceGénérale/EMS/EN/ems-moederl_PortalMillingMachineGeneralDesignConsideration_files/a.html

@@ -0,0 +1,2 @@
+<html><head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8"></head><body></body></html>

RessourceGénérale/EMS/EN/ems-moederl_PortalMillingMachineGeneralDesignConsideration_files/effects.js

@@ -0,0 +1,903 @@
+// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+// Contributors:
+//  Justin Palmer (http://encytemedia.com/)
+//  Mark Pilgrim (http://diveintomark.org/)
+//  Martin Bialasinki
+// 
+// See scriptaculous.js for full license.  
+
+/* ------------- element ext -------------- */  
+ 
+// converts rgb() and #xxx to #xxxxxx format,  
+// returns self (or first argument) if not convertable  
+String.prototype.parseColor = function() {  
+  var color = '#';  
+  if(this.slice(0,4) == 'rgb(') {  
+    var cols = this.slice(4,this.length-1).split(',');  
+    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);  
+  } else {  
+    if(this.slice(0,1) == '#') {  
+      if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();  
+      if(this.length==7) color = this.toLowerCase();  
+    }  
+  }  
+  return(color.length==7 ? color : (arguments[0] || this));  
+}
+
+Element.collectTextNodes = function(element) {  
+  return $A($(element).childNodes).collect( function(node) {
+    return (node.nodeType==3 ? node.nodeValue : 
+      (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
+  }).flatten().join('');
+}
+
+Element.collectTextNodesIgnoreClass = function(element, className) {  
+  return $A($(element).childNodes).collect( function(node) {
+    return (node.nodeType==3 ? node.nodeValue : 
+      ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
+        Element.collectTextNodes(node) : ''));
+  }).flatten().join('');
+}
+
+Element.setStyle = function(element, style) {
+  element = $(element);
+  for(k in style) element.style[k.camelize()] = style[k];
+}
+
+Element.setContentZoom = function(element, percent) {  
+  Element.setStyle(element, {fontSize: (percent/100) + 'em'});   
+  if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);  
+}
+
+Element.getOpacity = function(element){  
+  var opacity;
+  if (opacity = Element.getStyle(element, 'opacity'))  
+    return parseFloat(opacity);  
+  if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/))  
+    if(opacity[1]) return parseFloat(opacity[1]) / 100;  
+  return 1.0;  
+}
+
+Element.setOpacity = function(element, value){  
+  element= $(element);  
+  if (value == 1){
+    Element.setStyle(element, { opacity: 
+      (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
+      0.999999 : null });
+    if(/MSIE/.test(navigator.userAgent))  
+      Element.setStyle(element, {filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});  
+  } else {  
+    if(value < 0.00001) value = 0;  
+    Element.setStyle(element, {opacity: value});
+    if(/MSIE/.test(navigator.userAgent))  
+     Element.setStyle(element, 
+       { filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
+                 'alpha(opacity='+value*100+')' });  
+  }   
+}  
+ 
+Element.getInlineOpacity = function(element){  
+  return $(element).style.opacity || '';
+}  
+
+Element.childrenWithClassName = function(element, className) {  
+  return $A($(element).getElementsByTagName('*')).select(
+    function(c) { return Element.hasClassName(c, className) });
+}
+
+Array.prototype.call = function() {
+  var args = arguments;
+  this.each(function(f){ f.apply(this, args) });
+}
+
+/*--------------------------------------------------------------------------*/
+
+var Effect = {
+  tagifyText: function(element) {
+    var tagifyStyle = 'position:relative';
+    if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
+    element = $(element);
+    $A(element.childNodes).each( function(child) {
+      if(child.nodeType==3) {
+        child.nodeValue.toArray().each( function(character) {
+          element.insertBefore(
+            Builder.node('span',{style: tagifyStyle},
+              character == ' ' ? String.fromCharCode(160) : character), 
+              child);
+        });
+        Element.remove(child);
+      }
+    });
+  },
+  multiple: function(element, effect) {
+    var elements;
+    if(((typeof element == 'object') || 
+        (typeof element == 'function')) && 
+       (element.length))
+      elements = element;
+    else
+      elements = $(element).childNodes;
+      
+    var options = Object.extend({
+      speed: 0.1,
+      delay: 0.0
+    }, arguments[2] || {});
+    var masterDelay = options.delay;
+
+    $A(elements).each( function(element, index) {
+      new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
+    });
+  },
+  PAIRS: {
+    'slide':  ['SlideDown','SlideUp'],
+    'blind':  ['BlindDown','BlindUp'],
+    'appear': ['Appear','Fade']
+  },
+  toggle: function(element, effect) {
+    element = $(element);
+    effect = (effect || 'appear').toLowerCase();
+    var options = Object.extend({
+      queue: { position:'end', scope:(element.id || 'global') }
+    }, arguments[2] || {});
+    Effect[Element.visible(element) ? 
+      Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
+  }
+};
+
+var Effect2 = Effect; // deprecated
+
+/* ------------- transitions ------------- */
+
+Effect.Transitions = {}
+
+Effect.Transitions.linear = function(pos) {
+  return pos;
+}
+Effect.Transitions.sinoidal = function(pos) {
+  return (-Math.cos(pos*Math.PI)/2) + 0.5;
+}
+Effect.Transitions.reverse  = function(pos) {
+  return 1-pos;
+}
+Effect.Transitions.flicker = function(pos) {
+  return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
+}
+Effect.Transitions.wobble = function(pos) {
+  return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
+}
+Effect.Transitions.pulse = function(pos) {
+  return (Math.floor(pos*10) % 2 == 0 ? 
+    (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
+}
+Effect.Transitions.none = function(pos) {
+  return 0;
+}
+Effect.Transitions.full = function(pos) {
+  return 1;
+}
+
+/* ------------- core effects ------------- */
+
+Effect.ScopedQueue = Class.create();
+Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
+  initialize: function() {
+    this.effects  = [];
+    this.interval = null;
+  },
+  _each: function(iterator) {
+    this.effects._each(iterator);
+  },
+  add: function(effect) {
+    var timestamp = new Date().getTime();
+    
+    var position = (typeof effect.options.queue == 'string') ? 
+      effect.options.queue : effect.options.queue.position;
+    
+    switch(position) {
+      case 'front':
+        // move unstarted effects after this effect  
+        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
+            e.startOn  += effect.finishOn;
+            e.finishOn += effect.finishOn;
+          });
+        break;
+      case 'end':
+        // start effect after last queued effect has finished
+        timestamp = this.effects.pluck('finishOn').max() || timestamp;
+        break;
+    }
+    
+    effect.startOn  += timestamp;
+    effect.finishOn += timestamp;
+    this.effects.push(effect);
+    if(!this.interval) 
+      this.interval = setInterval(this.loop.bind(this), 40);
+  },
+  remove: function(effect) {
+    this.effects = this.effects.reject(function(e) { return e==effect });
+    if(this.effects.length == 0) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  },
+  loop: function() {
+    var timePos = new Date().getTime();
+    this.effects.invoke('loop', timePos);
+  }
+});
+
+Effect.Queues = {
+  instances: $H(),
+  get: function(queueName) {
+    if(typeof queueName != 'string') return queueName;
+    
+    if(!this.instances[queueName])
+      this.instances[queueName] = new Effect.ScopedQueue();
+      
+    return this.instances[queueName];
+  }
+}
+Effect.Queue = Effect.Queues.get('global');
+
+Effect.DefaultOptions = {
+  transition: Effect.Transitions.sinoidal,
+  duration:   1.0,   // seconds
+  fps:        25.0,  // max. 25fps due to Effect.Queue implementation
+  sync:       false, // true for combining
+  from:       0.0,
+  to:         1.0,
+  delay:      0.0,
+  queue:      'parallel'
+}
+
+Effect.Base = function() {};
+Effect.Base.prototype = {
+  position: null,
+  start: function(options) {
+    this.options      = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
+    this.currentFrame = 0;
+    this.state        = 'idle';
+    this.startOn      = this.options.delay*1000;
+    this.finishOn     = this.startOn + (this.options.duration*1000);
+    this.event('beforeStart');
+    if(!this.options.sync)
+      Effect.Queues.get(typeof this.options.queue == 'string' ? 
+        'global' : this.options.queue.scope).add(this);
+  },
+  loop: function(timePos) {
+    if(timePos >= this.startOn) {
+      if(timePos >= this.finishOn) {
+        this.render(1.0);
+        this.cancel();
+        this.event('beforeFinish');
+        if(this.finish) this.finish(); 
+        this.event('afterFinish');
+        return;  
+      }
+      var pos   = (timePos - this.startOn) / (this.finishOn - this.startOn);
+      var frame = Math.round(pos * this.options.fps * this.options.duration);
+      if(frame > this.currentFrame) {
+        this.render(pos);
+        this.currentFrame = frame;
+      }
+    }
+  },
+  render: function(pos) {
+    if(this.state == 'idle') {
+      this.state = 'running';
+      this.event('beforeSetup');
+      if(this.setup) this.setup();
+      this.event('afterSetup');
+    }
+    if(this.state == 'running') {
+      if(this.options.transition) pos = this.options.transition(pos);
+      pos *= (this.options.to-this.options.from);
+      pos += this.options.from;
+      this.position = pos;
+      this.event('beforeUpdate');
+      if(this.update) this.update(pos);
+      this.event('afterUpdate');
+    }
+  },
+  cancel: function() {
+    if(!this.options.sync)
+      Effect.Queues.get(typeof this.options.queue == 'string' ? 
+        'global' : this.options.queue.scope).remove(this);
+    this.state = 'finished';
+  },
+  event: function(eventName) {
+    if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
+    if(this.options[eventName]) this.options[eventName](this);
+  },
+  inspect: function() {
+    return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
+  }
+}
+
+Effect.Parallel = Class.create();
+Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
+  initialize: function(effects) {
+    this.effects = effects || [];
+    this.start(arguments[1]);
+  },
+  update: function(position) {
+    this.effects.invoke('render', position);
+  },
+  finish: function(position) {
+    this.effects.each( function(effect) {
+      effect.render(1.0);
+      effect.cancel();
+      effect.event('beforeFinish');
+      if(effect.finish) effect.finish(position);
+      effect.event('afterFinish');
+    });
+  }
+});
+
+Effect.Opacity = Class.create();
+Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    // make this work on IE on elements without 'layout'
+    if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
+      Element.setStyle(this.element, {zoom: 1});
+    var options = Object.extend({
+      from: Element.getOpacity(this.element) || 0.0,
+      to:   1.0
+    }, arguments[1] || {});
+    this.start(options);
+  },
+  update: function(position) {
+    Element.setOpacity(this.element, position);
+  }
+});
+
+Effect.Move = Class.create();
+Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    var options = Object.extend({
+      x:    0,
+      y:    0,
+      mode: 'relative'
+    }, arguments[1] || {});
+    this.start(options);
+  },
+  setup: function() {
+    // Bug in Opera: Opera returns the "real" position of a static element or
+    // relative element that does not have top/left explicitly set.
+    // ==> Always set top and left for position relative elements in your stylesheets 
+    // (to 0 if you do not need them) 
+    Element.makePositioned(this.element);
+    this.originalLeft = parseFloat(Element.getStyle(this.element,'left') || '0');
+    this.originalTop  = parseFloat(Element.getStyle(this.element,'top')  || '0');
+    if(this.options.mode == 'absolute') {
+      // absolute movement, so we need to calc deltaX and deltaY
+      this.options.x = this.options.x - this.originalLeft;
+      this.options.y = this.options.y - this.originalTop;
+    }
+  },
+  update: function(position) {
+    Element.setStyle(this.element, {
+      left: this.options.x  * position + this.originalLeft + 'px',
+      top:  this.options.y  * position + this.originalTop  + 'px'
+    });
+  }
+});
+
+// for backwards compatibility
+Effect.MoveBy = function(element, toTop, toLeft) {
+  return new Effect.Move(element, 
+    Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
+};
+
+Effect.Scale = Class.create();
+Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
+  initialize: function(element, percent) {
+    this.element = $(element)
+    var options = Object.extend({
+      scaleX: true,
+      scaleY: true,
+      scaleContent: true,
+      scaleFromCenter: false,
+      scaleMode: 'box',        // 'box' or 'contents' or {} with provided values
+      scaleFrom: 100.0,
+      scaleTo:   percent
+    }, arguments[2] || {});
+    this.start(options);
+  },
+  setup: function() {
+    this.restoreAfterFinish = this.options.restoreAfterFinish || false;
+    this.elementPositioning = Element.getStyle(this.element,'position');
+    
+    this.originalStyle = {};
+    ['top','left','width','height','fontSize'].each( function(k) {
+      this.originalStyle[k] = this.element.style[k];
+    }.bind(this));
+      
+    this.originalTop  = this.element.offsetTop;
+    this.originalLeft = this.element.offsetLeft;
+    
+    var fontSize = Element.getStyle(this.element,'font-size') || '100%';
+    ['em','px','%'].each( function(fontSizeType) {
+      if(fontSize.indexOf(fontSizeType)>0) {
+        this.fontSize     = parseFloat(fontSize);
+        this.fontSizeType = fontSizeType;
+      }
+    }.bind(this));
+    
+    this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
+    
+    this.dims = null;
+    if(this.options.scaleMode=='box')
+      this.dims = [this.element.offsetHeight, this.element.offsetWidth];
+    if(/^content/.test(this.options.scaleMode))
+      this.dims = [this.element.scrollHeight, this.element.scrollWidth];
+    if(!this.dims)
+      this.dims = [this.options.scaleMode.originalHeight,
+                   this.options.scaleMode.originalWidth];
+  },
+  update: function(position) {
+    var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
+    if(this.options.scaleContent && this.fontSize)
+      Element.setStyle(this.element, {fontSize: this.fontSize * currentScale + this.fontSizeType });
+    this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
+  },
+  finish: function(position) {
+    if (this.restoreAfterFinish) Element.setStyle(this.element, this.originalStyle);
+  },
+  setDimensions: function(height, width) {
+    var d = {};
+    if(this.options.scaleX) d.width = width + 'px';
+    if(this.options.scaleY) d.height = height + 'px';
+    if(this.options.scaleFromCenter) {
+      var topd  = (height - this.dims[0])/2;
+      var leftd = (width  - this.dims[1])/2;
+      if(this.elementPositioning == 'absolute') {
+        if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
+        if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
+      } else {
+        if(this.options.scaleY) d.top = -topd + 'px';
+        if(this.options.scaleX) d.left = -leftd + 'px';
+      }
+    }
+    Element.setStyle(this.element, d);
+  }
+});
+
+Effect.Highlight = Class.create();
+Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
+    this.start(options);
+  },
+  setup: function() {
+    // Prevent executing on elements not in the layout flow
+    if(Element.getStyle(this.element, 'display')=='none') { this.cancel(); return; }
+    // Disable background image during the effect
+    this.oldStyle = {
+      backgroundImage: Element.getStyle(this.element, 'background-image') };
+    Element.setStyle(this.element, {backgroundImage: 'none'});
+    if(!this.options.endcolor)
+      this.options.endcolor = Element.getStyle(this.element, 'background-color').parseColor('#ffffff');
+    if(!this.options.restorecolor)
+      this.options.restorecolor = Element.getStyle(this.element, 'background-color');
+    // init color calculations
+    this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
+    this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
+  },
+  update: function(position) {
+    Element.setStyle(this.element,{backgroundColor: $R(0,2).inject('#',function(m,v,i){
+      return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
+  },
+  finish: function() {
+    Element.setStyle(this.element, Object.extend(this.oldStyle, {
+      backgroundColor: this.options.restorecolor
+    }));
+  }
+});
+
+Effect.ScrollTo = Class.create();
+Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
+  initialize: function(element) {
+    this.element = $(element);
+    this.start(arguments[1] || {});
+  },
+  setup: function() {
+    Position.prepare();
+    var offsets = Position.cumulativeOffset(this.element);
+    if(this.options.offset) offsets[1] += this.options.offset;
+    var max = window.innerHeight ? 
+      window.height - window.innerHeight :
+      document.body.scrollHeight - 
+        (document.documentElement.clientHeight ? 
+          document.documentElement.clientHeight : document.body.clientHeight);
+    this.scrollStart = Position.deltaY;
+    this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
+  },
+  update: function(position) {
+    Position.prepare();
+    window.scrollTo(Position.deltaX, 
+      this.scrollStart + (position*this.delta));
+  }
+});
+
+/* ------------- combination effects ------------- */
+
+Effect.Fade = function(element) {
+  var oldOpacity = Element.getInlineOpacity(element);
+  var options = Object.extend({
+  from: Element.getOpacity(element) || 1.0,
+  to:   0.0,
+  afterFinishInternal: function(effect) { with(Element) { 
+    if(effect.options.to!=0) return;
+    hide(effect.element);
+    setStyle(effect.element, {opacity: oldOpacity}); }}
+  }, arguments[1] || {});
+  return new Effect.Opacity(element,options);
+}
+
+Effect.Appear = function(element) {
+  var options = Object.extend({
+  from: (Element.getStyle(element, 'display') == 'none' ? 0.0 : Element.getOpacity(element) || 0.0),
+  to:   1.0,
+  beforeSetup: function(effect) { with(Element) {
+    setOpacity(effect.element, effect.options.from);
+    show(effect.element); }}
+  }, arguments[1] || {});
+  return new Effect.Opacity(element,options);
+}
+
+Effect.Puff = function(element) {
+  element = $(element);
+  var oldStyle = { opacity: Element.getInlineOpacity(element), position: Element.getStyle(element, 'position') };
+  return new Effect.Parallel(
+   [ new Effect.Scale(element, 200, 
+      { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
+     new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
+     Object.extend({ duration: 1.0, 
+      beforeSetupInternal: function(effect) { with(Element) {
+        setStyle(effect.effects[0].element, {position: 'absolute'}); }},
+      afterFinishInternal: function(effect) { with(Element) {
+         hide(effect.effects[0].element);
+         setStyle(effect.effects[0].element, oldStyle); }}
+     }, arguments[1] || {})
+   );
+}
+
+Effect.BlindUp = function(element) {
+  element = $(element);
+  Element.makeClipping(element);
+  return new Effect.Scale(element, 0, 
+    Object.extend({ scaleContent: false, 
+      scaleX: false, 
+      restoreAfterFinish: true,
+      afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); }} 
+    }, arguments[1] || {})
+  );
+}
+
+Effect.BlindDown = function(element) {
+  element = $(element);
+  var oldHeight = Element.getStyle(element, 'height');
+  var elementDimensions = Element.getDimensions(element);
+  return new Effect.Scale(element, 100, 
+    Object.extend({ scaleContent: false, 
+      scaleX: false,
+      scaleFrom: 0,
+      scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
+      restoreAfterFinish: true,
+      afterSetup: function(effect) { with(Element) {
+        makeClipping(effect.element);
+        setStyle(effect.element, {height: '0px'});
+        show(effect.element); 
+      }},  
+      afterFinishInternal: function(effect) { with(Element) {
+        undoClipping(effect.element);
+        setStyle(effect.element, {height: oldHeight});
+      }}
+    }, arguments[1] || {})
+  );
+}
+
+Effect.SwitchOff = function(element) {
+  element = $(element);
+  var oldOpacity = Element.getInlineOpacity(element);
+  return new Effect.Appear(element, { 
+    duration: 0.4,
+    from: 0,
+    transition: Effect.Transitions.flicker,
+    afterFinishInternal: function(effect) {
+      new Effect.Scale(effect.element, 1, { 
+        duration: 0.3, scaleFromCenter: true,
+        scaleX: false, scaleContent: false, restoreAfterFinish: true,
+        beforeSetup: function(effect) { with(Element) {
+          [makePositioned,makeClipping].call(effect.element);
+        }},
+        afterFinishInternal: function(effect) { with(Element) {
+          [hide,undoClipping,undoPositioned].call(effect.element);
+          setStyle(effect.element, {opacity: oldOpacity});
+        }}
+      })
+    }
+  });
+}
+
+Effect.DropOut = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: Element.getStyle(element, 'top'),
+    left: Element.getStyle(element, 'left'),
+    opacity: Element.getInlineOpacity(element) };
+  return new Effect.Parallel(
+    [ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
+      new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
+    Object.extend(
+      { duration: 0.5,
+        beforeSetup: function(effect) { with(Element) {
+          makePositioned(effect.effects[0].element); }},
+        afterFinishInternal: function(effect) { with(Element) {
+          [hide, undoPositioned].call(effect.effects[0].element);
+          setStyle(effect.effects[0].element, oldStyle); }} 
+      }, arguments[1] || {}));
+}
+
+Effect.Shake = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: Element.getStyle(element, 'top'),
+    left: Element.getStyle(element, 'left') };
+	  return new Effect.Move(element, 
+	    { x:  20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
+	  new Effect.Move(effect.element,
+	    { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) { with(Element) {
+        undoPositioned(effect.element);
+        setStyle(effect.element, oldStyle);
+  }}}) }}) }}) }}) }}) }});
+}
+
+Effect.SlideDown = function(element) {
+  element = $(element);
+  Element.cleanWhitespace(element);
+  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
+  var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+  var elementDimensions = Element.getDimensions(element);
+  return new Effect.Scale(element, 100, Object.extend({ 
+    scaleContent: false, 
+    scaleX: false, 
+    scaleFrom: 0,
+    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
+    restoreAfterFinish: true,
+    afterSetup: function(effect) { with(Element) {
+      makePositioned(effect.element);
+      makePositioned(effect.element.firstChild);
+      if(window.opera) setStyle(effect.element, {top: ''});
+      makeClipping(effect.element);
+      setStyle(effect.element, {height: '0px'});
+      show(element); }},
+    afterUpdateInternal: function(effect) { with(Element) {
+      setStyle(effect.element.firstChild, {bottom:
+        (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+    afterFinishInternal: function(effect) { with(Element) {
+      undoClipping(effect.element); 
+      undoPositioned(effect.element.firstChild);
+      undoPositioned(effect.element);
+      setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
+    }, arguments[1] || {})
+  );
+}
+  
+Effect.SlideUp = function(element) {
+  element = $(element);
+  Element.cleanWhitespace(element);
+  var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+  return new Effect.Scale(element, 0, 
+   Object.extend({ scaleContent: false, 
+    scaleX: false, 
+    scaleMode: 'box',
+    scaleFrom: 100,
+    restoreAfterFinish: true,
+    beforeStartInternal: function(effect) { with(Element) {
+      makePositioned(effect.element);
+      makePositioned(effect.element.firstChild);
+      if(window.opera) setStyle(effect.element, {top: ''});
+      makeClipping(effect.element);
+      show(element); }},  
+    afterUpdateInternal: function(effect) { with(Element) {
+      setStyle(effect.element.firstChild, {bottom:
+        (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+    afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); 
+        undoPositioned(effect.element.firstChild);
+        undoPositioned(effect.element);
+        setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
+   }, arguments[1] || {})
+  );
+}
+
+// Bug in opera makes the TD containing this element expand for a instance after finish 
+Effect.Squish = function(element) {
+  return new Effect.Scale(element, window.opera ? 1 : 0, 
+    { restoreAfterFinish: true,
+      beforeSetup: function(effect) { with(Element) {
+        makeClipping(effect.element); }},  
+      afterFinishInternal: function(effect) { with(Element) {
+        hide(effect.element); 
+        undoClipping(effect.element); }}
+  });
+}
+
+Effect.Grow = function(element) {
+  element = $(element);
+  var options = Object.extend({
+    direction: 'center',
+    moveTransistion: Effect.Transitions.sinoidal,
+    scaleTransition: Effect.Transitions.sinoidal,
+    opacityTransition: Effect.Transitions.full
+  }, arguments[1] || {});
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    height: element.style.height,
+    width: element.style.width,
+    opacity: Element.getInlineOpacity(element) };
+
+  var dims = Element.getDimensions(element);    
+  var initialMoveX, initialMoveY;
+  var moveX, moveY;
+  
+  switch (options.direction) {
+    case 'top-left':
+      initialMoveX = initialMoveY = moveX = moveY = 0; 
+      break;
+    case 'top-right':
+      initialMoveX = dims.width;
+      initialMoveY = moveY = 0;
+      moveX = -dims.width;
+      break;
+    case 'bottom-left':
+      initialMoveX = moveX = 0;
+      initialMoveY = dims.height;
+      moveY = -dims.height;
+      break;
+    case 'bottom-right':
+      initialMoveX = dims.width;
+      initialMoveY = dims.height;
+      moveX = -dims.width;
+      moveY = -dims.height;
+      break;
+    case 'center':
+      initialMoveX = dims.width / 2;
+      initialMoveY = dims.height / 2;
+      moveX = -dims.width / 2;
+      moveY = -dims.height / 2;
+      break;
+  }
+  
+  return new Effect.Move(element, {
+    x: initialMoveX,
+    y: initialMoveY,
+    duration: 0.01, 
+    beforeSetup: function(effect) { with(Element) {
+      hide(effect.element);
+      makeClipping(effect.element);
+      makePositioned(effect.element);
+    }},
+    afterFinishInternal: function(effect) {
+      new Effect.Parallel(
+        [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
+          new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
+          new Effect.Scale(effect.element, 100, {
+            scaleMode: { originalHeight: dims.height, originalWidth: dims.width }, 
+            sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
+        ], Object.extend({
+             beforeSetup: function(effect) { with(Element) {
+               setStyle(effect.effects[0].element, {height: '0px'});
+               show(effect.effects[0].element); }},
+             afterFinishInternal: function(effect) { with(Element) {
+               [undoClipping, undoPositioned].call(effect.effects[0].element); 
+               setStyle(effect.effects[0].element, oldStyle); }}
+           }, options)
+      )
+    }
+  });
+}
+
+Effect.Shrink = function(element) {
+  element = $(element);
+  var options = Object.extend({
+    direction: 'center',
+    moveTransistion: Effect.Transitions.sinoidal,
+    scaleTransition: Effect.Transitions.sinoidal,
+    opacityTransition: Effect.Transitions.none
+  }, arguments[1] || {});
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    height: element.style.height,
+    width: element.style.width,
+    opacity: Element.getInlineOpacity(element) };
+
+  var dims = Element.getDimensions(element);
+  var moveX, moveY;
+  
+  switch (options.direction) {
+    case 'top-left':
+      moveX = moveY = 0;
+      break;
+    case 'top-right':
+      moveX = dims.width;
+      moveY = 0;
+      break;
+    case 'bottom-left':
+      moveX = 0;
+      moveY = dims.height;
+      break;
+    case 'bottom-right':
+      moveX = dims.width;
+      moveY = dims.height;
+      break;
+    case 'center':  
+      moveX = dims.width / 2;
+      moveY = dims.height / 2;
+      break;
+  }
+  
+  return new Effect.Parallel(
+    [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
+      new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
+      new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
+    ], Object.extend({            
+         beforeStartInternal: function(effect) { with(Element) {
+           [makePositioned, makeClipping].call(effect.effects[0].element) }},
+         afterFinishInternal: function(effect) { with(Element) {
+           [hide, undoClipping, undoPositioned].call(effect.effects[0].element);
+           setStyle(effect.effects[0].element, oldStyle); }}
+       }, options)
+  );
+}
+
+Effect.Pulsate = function(element) {
+  element = $(element);
+  var options    = arguments[1] || {};
+  var oldOpacity = Element.getInlineOpacity(element);
+  var transition = options.transition || Effect.Transitions.sinoidal;
+  var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };
+  reverser.bind(transition);
+  return new Effect.Opacity(element, 
+    Object.extend(Object.extend({  duration: 3.0, from: 0,
+      afterFinishInternal: function(effect) { Element.setStyle(effect.element, {opacity: oldOpacity}); }
+    }, options), {transition: reverser}));
+}
+
+Effect.Fold = function(element) {
+  element = $(element);
+  var oldStyle = {
+    top: element.style.top,
+    left: element.style.left,
+    width: element.style.width,
+    height: element.style.height };
+  Element.makeClipping(element);
+  return new Effect.Scale(element, 5, Object.extend({   
+    scaleContent: false,
+    scaleX: false,
+    afterFinishInternal: function(effect) {
+    new Effect.Scale(element, 1, { 
+      scaleContent: false, 
+      scaleY: false,
+      afterFinishInternal: function(effect) { with(Element) {
+        [hide, undoClipping].call(effect.element); 
+        setStyle(effect.element, oldStyle);
+      }} });
+  }}, arguments[1] || {}));
+}