threequarks 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 978cd8fcbaceda6a1f785e1a518df94dce369798
+  data.tar.gz: 882f0c67fc0b9f1b06698f7a950516873d8a6087
+SHA512:
+  metadata.gz: a048b09aec0f5ce14b8f88cd3267188b371431322ed04722888cfa0410a731b7ee8d7e4fcf42e65f8bfbb09a21f57bc304ab3114d2a8149b40b0b618c5cd909a
+  data.tar.gz: cca2bd37031df050ad505b036b784bd0ac3942c4d680ec7ccc5170054c9f00b07094cb4949be5bf69e499cdf3f52dd338d785134d85cbcc46ea7d04037b0d168

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in threequarks.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Julien Le Glaunec
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# Threequarks - Station Clock
+
+This gem allows you to use the Canvas Station Clock http://www.3quarks.com/en/StationClock/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'threequarks'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install threequarks
+
+## Usage
+Add the following line to your application.js file
+
+    //= require threequarks
+
+Display the UTC time
+```html
+<div 
+  class='clock'
+  offset='0'
+  body='<%= Threequarks::RoundBody %>'
+  dial='<%= Threequarks::SwissStrokeDial %>'
+  hourHand='<%= Threequarks::SwissHourHand %>'
+  minuteHand='<%= Threequarks::SwissMinuteHand %>'
+  secondHand='<%= Threequarks::SwissSecondHand %>'
+  boss='<%= Threequarks::NoBoss %>'
+  minuteHandBehavior='<%= Threequarks::BouncingMinuteHand %>'
+  secondHandBehavior='<%= Threequarks::OverhastySecondHand %>'
+  redrawInterval='1000'>
+  <canvas id='clockUTC' width='100' height='100'></canvas>
+  <p>UTC Time</p>
+</div>
+```
+
+Display the local time
+```html
+<div 
+  class='clock'
+  body='<%= Threequarks::RoundBody %>'
+  dial='<%= Threequarks::SwissStrokeDial %>'
+  hourHand='<%= Threequarks::SwissHourHand %>'
+  minuteHand='<%= Threequarks::SwissMinuteHand %>'
+  secondHand='<%= Threequarks::SwissSecondHand %>'
+  boss='<%= Threequarks::NoBoss %>'
+  minuteHandBehavior='<%= Threequarks::BouncingMinuteHand %>'
+  secondHandBehavior='<%= Threequarks::OverhastySecondHand %>'
+  redrawInterval='1000'>
+  <canvas id='clockLocal' width='100' height='100'></canvas>
+  <p>Local Time (without offset attribute)</p>
+</div>
+```
+
+List of different options
+
+    # clock body
+    NoBody         = 0
+    SmallWhiteBody = 1
+    RoundBody      = 2
+    RoundGreenBody = 3
+    SquareBody     = 4
+
+    # stroke dial
+    NoDial               = 0
+    GermanHourStrokeDial = 1
+    GermanStrokeDial     = 2
+    AustriaStrokeDial    = 3
+    SwissStrokeDial      = 4
+
+    #clock hour hand
+    PointedHourHand = 1
+    BarHourHand     = 2
+    SwissHourHand   = 3
+
+    #clock minute hand
+    PointedMinuteHand = 1
+    BarMinuteHand     = 2
+    SwissMinuteHand   = 3
+
+    #clock second hand
+    NoSecondHand            = 0
+    BarSecondHand           = 1
+    HoleShapedSecondHand    = 2
+    NewHoleShapedSecondHand = 3
+    SwissSecondHand         = 4
+
+    # clock boss
+    NoBoss    = 0
+    BlackBoss = 1
+    RedBoss   = 2
+
+    # minute hand behavior
+    CreepingMinuteHand        = 0
+    BouncingMinuteHand        = 1
+    ElasticBouncingMinuteHand = 2
+
+    # second hand behavior
+    CreepingSecondHand        = 0
+    BouncingSecondHand        = 1
+    ElasticBouncingSecondHand = 2
+    OverhastySecondHand       = 3
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/threequarks/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+src: http://www.sitepoint.com/create-ruby-gem-jquery-plugin-basics/

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/app/assets/javascript/station-clock.js

@@ -0,0 +1,415 @@
+/*!
+ * station-clock.js
+ *
+ * Copyright (c) 2010 Ruediger Appel
+ * ludi at mac dot com
+ *
+ * Date: 2010-08-08
+ * Version: 1.0.0
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Known Issues:
+ *
+ *   Shadows for some second hands is not on one layer
+ */
+
+// clock body (Uhrgehäuse)
+StationClock.NoBody         = 0;
+StationClock.SmallWhiteBody = 1;
+StationClock.RoundBody      = 2;
+StationClock.RoundGreenBody = 3;
+StationClock.SquareBody     = 4;
+
+// stroke dial (Zifferblatt)
+StationClock.NoDial               = 0;
+StationClock.GermanHourStrokeDial = 1;
+StationClock.GermanStrokeDial     = 2;
+StationClock.AustriaStrokeDial    = 3;
+StationClock.SwissStrokeDial      = 4;
+
+//clock hour hand (Stundenzeiger)
+StationClock.PointedHourHand = 1;
+StationClock.BarHourHand     = 2;
+StationClock.SwissHourHand   = 3;
+
+//clock minute hand (Minutenzeiger)
+StationClock.PointedMinuteHand = 1;
+StationClock.BarMinuteHand     = 2;
+StationClock.SwissMinuteHand   = 3;
+
+//clock second hand (Sekundenzeiger)
+StationClock.NoSecondHand            = 0;
+StationClock.BarSecondHand           = 1;
+StationClock.HoleShapedSecondHand    = 2;
+StationClock.NewHoleShapedSecondHand = 3;
+StationClock.SwissSecondHand         = 4;
+
+// clock boss (Zeigerabdeckung)
+StationClock.NoBoss    = 0;
+StationClock.BlackBoss = 1;
+StationClock.RedBoss   = 2;
+
+// minute hand behavoir
+StationClock.CreepingMinuteHand        = 0;
+StationClock.BouncingMinuteHand        = 1;
+StationClock.ElasticBouncingMinuteHand = 2;
+
+// second hand behavoir
+StationClock.CreepingSecondHand        = 0;
+StationClock.BouncingSecondHand        = 1;
+StationClock.ElasticBouncingSecondHand = 2;
+StationClock.OverhastySecondHand       = 3;
+
+
+function StationClock(clockId, offset) {
+  this.clockId = clockId; 
+  this.offset = offset
+  this.radius  = 0;
+
+  // clock body
+  this.body              = StationClock.RoundBody;
+  this.bodyShadowColor   = "rgba(0,0,0,0.5)";
+  this.bodyShadowOffsetX = 0.03;
+  this.bodyShadowOffsetY = 0.03;
+  this.bodyShadowBlur    = 0.06;
+  
+  // body dial
+  this.dial = StationClock.SwissStrokeDial;
+  
+  // clock hands
+  this.hourHand          = StationClock.SwissHourHand;
+  this.minuteHand        = StationClock.SwissMinuteHand;
+  this.secondHand        = StationClock.SwissSecondHand;
+  this.handShadowColor   = "rgba(0,0,0,0.3)";
+  this.handShadowOffsetX = 0.03;
+  this.handShadowOffsetY = 0.03;
+  this.handShadowBlur    = 0.04;
+  
+  // clock boss
+  this.boss              = StationClock.NoBoss;
+  this.bossShadowColor   = "rgba(0,0,0,0.2)";
+  this.bossShadowOffsetX = 0.02;
+  this.bossShadowOffsetY = 0.02;
+  this.bossShadowBlur    = 0.03;
+  
+  // hand behavoir
+  this.minuteHandBehavoir = StationClock.CreepingMinuteHand;
+  this.secondHandBehavoir = StationClock.OverhastySecondHand;
+  
+  // hand animation
+  this.minuteHandAnimationStep = 0;
+  this.secondHandAnimationStep = 0;
+  this.lastMinute = 0;
+  this.lastSecond = 0;
+};
+
+StationClock.prototype.draw = function() {
+  var clock = document.getElementById(this.clockId);
+  if (clock) {
+    var context = clock.getContext('2d');
+    if (context) {
+      this.radius = 0.75 * (Math.min(clock.width, clock.height) / 2);
+      
+      // clear canvas and set new origin
+      context.clearRect(0, 0, clock.width, clock.height);
+      context.save();
+      context.translate(clock.width / 2, clock.height / 2);
+      
+      // draw body
+      if (this.body != StationClock.NoStrokeBody) {
+        context.save();
+        switch (this.body) {
+		  case StationClock.SmallWhiteBody:
+		    this.fillCircle(context, "rgb(255,255,255)", 0, 0, 1);
+		    break;
+      case StationClock.RoundBody:
+        this.fillCircle(context, "rgb(255,255,255)", 0, 0, 1.1);
+        context.save();
+        this.setShadow(context, this.bodyShadowColor, this.bodyShadowOffsetX, this.bodyShadowOffsetY, this.bodyShadowBlur);
+        this.strokeCircle(context, "rgb(0,0,0)", 0, 0, 1.1, 0.07);
+        context.restore()
+        break;
+      case StationClock.RoundGreenBody:
+        this.fillCircle(context, "rgb(235,236,212)", 0, 0, 1.1);
+        context.save();
+        this.setShadow(context, this.bodyShadowColor, this.bodyShadowOffsetX, this.bodyShadowOffsetY, this.bodyShadowBlur);
+        this.strokeCircle(context, "rgb(180,180,180)", 0, 0, 1.1, 0.2);
+        context.restore()
+        this.strokeCircle(context, "rgb(29,84,31)", 0, 0, 1.15, 0.1);
+        context.save();
+        this.setShadow(context, "rgba(235,236,212,100)", -0.02, -0.02, 0.09);
+        this.strokeCircle(context, 'rgb(76,128,110)', 0, 0, 1.1, 0.08);
+        context.restore()
+        break;
+		  case StationClock.SquareBody:
+        context.save();
+        this.setShadow(context, this.bodyShadowColor, this.bodyShadowOffsetX, this.bodyShadowOffsetY, this.bodyShadowBlur);
+        this.fillSquare(context, 'rgb(237,235,226)', 0, 0, 2.4);
+        this.strokeSquare(context, 'rgb(38,106,186)', 0, 0, 2.32, 0.16);
+        context.restore()
+  			context.save();
+  			this.setShadow(context, this.bodyShadowColor, this.bodyShadowOffsetX, this.bodyShadowOffsetY, this.bodyShadowBlur);
+        this.strokeSquare(context, 'rgb(42,119,208)', 0, 0, 2.24, 0.08);
+  			context.restore()
+  			break;
+        }
+      context.restore();
+      }
+      
+      // draw dial
+      for (var i = 0; i < 60; i++) {
+        context.save();
+        context.rotate(i * Math.PI / 30);
+        switch (this.dial) {
+          case StationClock.SwissStrokeDial:
+            if ((i % 5) == 0) {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.75, 0.07);
+            } else {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.92, 0.026);
+            }
+            break;
+          case StationClock.AustriaStrokeDial:
+            if ((i % 5) == 0) {
+              this.fillPolygon(context, 'rgb(0,0,0)', -0.04, -1.0, 0.04, -1.0, 0.03, -0.78, -0.03, -0.78);
+            } else {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.94, 0.02);
+            }
+            break;
+          case StationClock.GermanStrokeDial:
+          	if ((i % 15) == 0) {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.70, 0.08);
+          	} else if ((i % 5) == 0) {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.76, 0.08);
+          	} else {
+          	  this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.92, 0.036);
+          	}
+          	break;
+          case StationClock.GermanHourStrokeDial:
+          	if ((i % 15) == 0) {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.70, 0.10);
+          	} else if ((i % 5) == 0) {
+              this.strokeLine(context, 'rgb(0,0,0)', 0.0, -1.0, 0.0, -0.74, 0.08);
+          	}
+          	break;
+        }
+        context.restore();
+      }
+
+      // get current time
+      var time    = new Date();
+      var millis  = time.getMilliseconds() / 1000.0;
+      var seconds = time.getSeconds();
+      // if this.offset == null, we show the local time
+      // if this.offset != null, we show the GMT+offset time
+      if (this.offset == null) {
+        var minutes = time.getMinutes()
+      } else {
+        var current_offset  = time.getTimezoneOffset()
+        var minutes = time.getMinutes() + current_offset + (this.offset*60);
+      }
+      var hours   = time.getHours();
+
+      // draw hour hand
+      context.save();
+      context.rotate(hours * Math.PI / 6 + minutes * Math.PI / 360);
+      this.setShadow(context, this.handShadowColor, this.handShadowOffsetX, this.handShadowOffsetY, this.handShadowBlur);
+      switch (this.hourHand) {
+        case StationClock.BarHourHand:
+          this.fillPolygon(context, 'rgb(0,0,0)', -0.05, -0.6, 0.05, -0.6, 0.05, 0.15, -0.05, 0.15);
+      	  break;
+        case StationClock.PointedHourHand:
+          this.fillPolygon(context, 'rgb(0,0,0)', 0.0, -0.6,  0.065, -0.53, 0.065, 0.19, -0.065, 0.19, -0.065, -0.53);
+          break;
+        case StationClock.SwissHourHand:
+          this.fillPolygon(context, 'rgb(0,0,0)', -0.05, -0.6, 0.05, -0.6, 0.065, 0.26, -0.065, 0.26);
+          break;
+      }
+      context.restore();
+      
+      // draw minute hand
+      context.save();
+      switch (this.minuteHandBehavoir) {
+        case StationClock.CreepingMinuteHand:
+          context.rotate((minutes + seconds / 60) * Math.PI / 30);
+  	      break;
+        case StationClock.BouncingMinuteHand:
+          context.rotate(minutes * Math.PI / 30);
+  	      break;
+        case StationClock.ElasticBouncingMinuteHand:
+          if (this.lastMinute != minutes) {
+            this.minuteHandAnimationStep = 3;
+            this.lastMinute = minutes;
+          }
+          context.rotate((minutes + this.getAnimationOffset(this.minuteHandAnimationStep)) * Math.PI / 30);
+          this.minuteHandAnimationStep--;
+          break;
+      }
+      this.setShadow(context, this.handShadowColor, this.handShadowOffsetX, this.handShadowOffsetY, this.handShadowBlur);
+      switch (this.minuteHand) {
+        case StationClock.BarMinuteHand:
+          this.fillPolygon(context, 'rgb(0,0,0)', -0.05, -0.6, 0.05, -0.6, 0.05, 0.15, -0.05, 0.15);
+      	  break;
+        case StationClock.PointedMinuteHand:
+          this.fillPolygon(context, 'rgb(0,0,0)', 0.0, -0.93,  0.045, -0.885, 0.045, 0.23, -0.045, 0.23, -0.045, -0.885);
+        	break;
+        case StationClock.SwissMinuteHand:
+        	this.fillPolygon(context, 'rgb(0,0,0)', -0.035, -0.93, 0.035, -0.93, 0.05, 0.25, -0.05, 0.25);
+        	break;
+      }
+      context.restore();
+      
+      // draw second hand
+      context.save();
+      switch (this.secondHandBehavoir) {
+        case StationClock.OverhastySecondHand:
+          context.rotate(Math.min((seconds + millis) * (60.0 / 58.5), 60.0) * Math.PI / 30);
+          break;
+        case StationClock.CreepingSecondHand:
+          context.rotate((seconds + millis) * Math.PI / 30);
+          break;
+        case StationClock.BouncingSecondHand:
+          context.rotate(seconds * Math.PI / 30);
+          break;
+        case StationClock.ElasticBouncingSecondHand:
+          if (this.lastSecond != seconds) {
+            this.secondHandAnimationStep = 3;
+            this.lastSecond = seconds;
+          }
+          context.rotate((seconds + this.getAnimationOffset(this.secondHandAnimationStep)) * Math.PI / 30);
+          this.secondHandAnimationStep--;
+          break;
+      }
+      this.setShadow(context, this.handShadowColor, this.handShadowOffsetX, this.handShadowOffsetY, this.handShadowBlur);
+      switch (this.secondHand) {
+        case StationClock.BarSecondHand:
+      	  this.fillPolygon(context, 'rgb(200,0,0)', -0.006, -0.92, 0.006, -0.92, 0.028, 0.23, -0.028, 0.23);
+      	  break;
+        case StationClock.HoleShapedSecondHand:
+          this.fillPolygon(context, 'rgb(200,0,0)', 0.0, -0.9, 0.011, -0.889, 0.01875, -0.6, -0.01875, -0.6, -0.011, -0.889);
+          this.fillPolygon(context, 'rgb(200,0,0)', 0.02, -0.4, 0.025, 0.22, -0.025, 0.22, -0.02, -0.4);
+          this.strokeCircle(context, 'rgb(200,0,0)', 0, -0.5, 0.083, 0.066);
+      	  break;
+        case StationClock.NewHoleShapedSecondHand:
+          this.fillPolygon(context, 'rgb(200,0,0)', 0.0, -0.95, 0.015, -0.935, 0.0187, -0.65, -0.0187, -0.65, -0.015, -0.935);
+          this.fillPolygon(context, 'rgb(200,0,0)', 0.022, -0.45, 0.03, 0.27, -0.03, 0.27, -0.022, -0.45);
+          this.strokeCircle(context, 'rgb(200,0,0)', 0, -0.55, 0.085, 0.07);
+      	  break;
+        case StationClock.SwissSecondHand:
+      	  this.strokeLine(context, 'rgb(200,0,0)', 0.0, -0.6, 0.0, 0.35, 0.026);
+      	  this.fillCircle(context, 'rgb(200,0,0)', 0, -0.64, 0.1);
+          break;
+      }
+      context.restore();
+      
+      // draw clock boss
+      if (this.boss != StationClock.NoBoss) {
+        context.save();
+        this.setShadow(context, this.bossShadowColor, this.bossShadowOffsetX, this.bossShadowOffsetY, this.bossShadowBlur);
+        switch (this.boss) {
+    		  case StationClock.BlackBoss:
+    		    this.fillCircle(context, 'rgb(0,0,0)', 0, 0, 0.1);
+    		    break;
+    		  case StationClock.RedBoss:
+    		    this.fillCircle(context, 'rgb(220,0,0)', 0, 0, 0.06);
+    		    break;
+        }
+        context.restore();
+      }
+      
+      context.restore();
+    }
+  }
+}
+
+StationClock.prototype.getAnimationOffset = function(animationStep) {
+  switch (animationStep) {
+    case 3: return  0.2;
+    case 2: return -0.1;
+    case 1: return  0.05;
+  }
+  return 0;
+}
+
+StationClock.prototype.setShadow = function(context, color, offsetX, offsetY, blur) {
+  if (color) {
+  	context.shadowColor   = color;
+  	context.shadowOffsetX = this.radius * offsetX;
+  	context.shadowOffsetY = this.radius * offsetY;
+  	context.shadowBlur    = this.radius * blur;
+  }
+}
+
+StationClock.prototype.fillCircle = function(context, color, x, y, radius) {
+  if (color) {
+    context.beginPath();
+    context.fillStyle = color;
+    context.arc(x * this.radius, y * this.radius, radius * this.radius, 0, 2 * Math.PI, true);
+    context.fill();
+  }
+}
+
+StationClock.prototype.strokeCircle = function(context, color, x, y, radius, lineWidth) {
+  if (color) {
+    context.beginPath();
+    context.strokeStyle = color;
+    context.lineWidth = lineWidth * this.radius;
+    context.arc(x * this.radius, y * this.radius, radius * this.radius, 0, 2 * Math.PI, true);
+    context.stroke();
+  }
+}
+
+StationClock.prototype.fillSquare = function(context, color, x, y, size) {
+  if (color) {
+    context.fillStyle = color;
+    context.fillRect((x - size / 2) * this.radius, (y -size / 2) * this.radius, size * this.radius, size * this.radius);
+  }
+}
+
+StationClock.prototype.strokeSquare = function(context, color, x, y, size, lineWidth) {
+  if (color) {
+    context.strokeStyle = color;
+    context.lineWidth = lineWidth * this.radius;
+    context.strokeRect((x - size / 2) * this.radius, (y -size / 2) * this.radius, size * this.radius, size * this.radius);
+  }
+}
+
+StationClock.prototype.strokeLine = function(context, color, x1, y1, x2, y2, width) {
+  if (color) {
+	  context.beginPath();
+	  context.strokeStyle = color;
+	  context.moveTo(x1 * this.radius, y1 * this.radius);
+	  context.lineTo(x2 * this.radius, y2 * this.radius);
+	  context.lineWidth = width * this.radius;
+	  context.stroke();
+  }
+}
+
+
+StationClock.prototype.fillPolygon = function(context, color, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5) {
+  if (color) {
+	  context.beginPath();
+	  context.fillStyle = color;
+	  context.moveTo(x1 * this.radius, y1 * this.radius);
+	  context.lineTo(x2 * this.radius, y2 * this.radius);
+	  context.lineTo(x3 * this.radius, y3 * this.radius);
+	  context.lineTo(x4 * this.radius, y4 * this.radius);
+	  if ((x5 != undefined) && (y5 != undefined)) {
+	    context.lineTo(x5 * this.radius, y5 * this.radius);
+	  }
+	  context.lineTo(x1 * this.radius, y1 * this.radius);
+	  context.fill();
+  }
+}
+
+

data/app/assets/javascript/threequarks.js

@@ -0,0 +1 @@
+//= require_tree .

data/app/assets/javascript/threequarks_initializer.js

@@ -0,0 +1,30 @@
+$(function() {
+
+  $('.clock').each(function(i, el) {
+    
+    var canvasId = $(el).children().first().attr('id');
+    var offset = $(el).attr('offset');
+    var body = $(el).attr('body') != null ? $(el).attr('body') : StationClock.RoundBody;
+    var dial = $(el).attr('dial') != null ? $(el).attr('dial') : StationClock.SwissStrokeDial;
+    var hourHand = $(el).attr('hourHand') != null ? $(el).attr('hourHand') : StationClock.SwissHourHand;
+    var minuteHand = $(el).attr('minuteHand') != null ? $(el).attr('minuteHand') : StationClock.SwissMinuteHand;
+    var secondHand = $(el).attr('secondHand') != null ? $(el).attr('secondHand') : StationClock.SwissSecondHand;
+    var boss = $(el).attr('boss') != null ? $(el).attr('boss') : StationClock.NoBoss;
+    var minuteHandBehavior = $(el).attr('minuteHandBehavior') != null ? $(el).attr('minuteHandBehavior') : StationClock.BouncingMinuteHand;
+    var secondHandBehavior = $(el).attr('secondHandBehavior') != null ? $(el).attr('secondHandBehavior') : StationClock.OverhastySecondHand;
+    var redrawInterval = $(el).attr('redrawInterval') != null ? $(el).attr('redrawInterval') : 50;
+
+    var clock = new StationClock(canvasId, offset);
+    clock.body = parseInt(body);
+    clock.dial = parseInt(dial);
+    clock.hourHand = parseInt(hourHand);
+    clock.minuteHand = parseInt(minuteHand);
+    clock.secondHand = parseInt(secondHand);
+    clock.boss = parseInt(boss);
+    clock.minuteHandBehavoir = parseInt(minuteHandBehavior);
+    clock.secondHandBehavoir = parseInt(secondHandBehavior);
+    window.setInterval(function() { clock.draw() }, parseInt(redrawInterval));
+
+  });
+
+});

data/lib/threequarks.rb

@@ -0,0 +1,53 @@
+require "threequarks/version"
+require "threequarks/engine"
+
+module Threequarks
+
+  # clock body
+  NoBody         = 0
+  SmallWhiteBody = 1
+  RoundBody      = 2
+  RoundGreenBody = 3
+  SquareBody     = 4
+
+  # stroke dial
+  NoDial               = 0
+  GermanHourStrokeDial = 1
+  GermanStrokeDial     = 2
+  AustriaStrokeDial    = 3
+  SwissStrokeDial      = 4
+
+  #clock hour hand
+  PointedHourHand = 1
+  BarHourHand     = 2
+  SwissHourHand   = 3
+
+  #clock minute hand
+  PointedMinuteHand = 1
+  BarMinuteHand     = 2
+  SwissMinuteHand   = 3
+
+  #clock second hand
+  NoSecondHand            = 0
+  BarSecondHand           = 1
+  HoleShapedSecondHand    = 2
+  NewHoleShapedSecondHand = 3
+  SwissSecondHand         = 4
+
+  # clock boss
+  NoBoss    = 0
+  BlackBoss = 1
+  RedBoss   = 2
+
+  # minute hand behavior
+  CreepingMinuteHand        = 0
+  BouncingMinuteHand        = 1
+  ElasticBouncingMinuteHand = 2
+
+  # second hand behavior
+  CreepingSecondHand        = 0
+  BouncingSecondHand        = 1
+  ElasticBouncingSecondHand = 2
+  OverhastySecondHand       = 3
+  
+end

data/lib/threequarks/engine.rb

@@ -0,0 +1,4 @@
+module Threequarks
+  class Engine < Rails::Engine
+  end
+end

data/lib/threequarks/version.rb

@@ -0,0 +1,3 @@
+module Threequarks
+  VERSION = "0.0.1"
+end

data/threequarks.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'threequarks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "threequarks"
+  spec.version       = Threequarks::VERSION
+  spec.authors       = ["Julien Le Glaunec"]
+  spec.email         = ["jleglaunec@gmail.com"]
+  spec.summary       = %q{Display a station clock on a website via SVG}
+  spec.description   = %q{source: http://www.3quarks.com/en/SVGClock/index.html}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: threequarks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julien Le Glaunec
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'source: http://www.3quarks.com/en/SVGClock/index.html'
+email:
+- jleglaunec@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascript/station-clock.js
+- app/assets/javascript/threequarks.js
+- app/assets/javascript/threequarks_initializer.js
+- lib/threequarks.rb
+- lib/threequarks/engine.rb
+- lib/threequarks/version.rb
+- threequarks.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Display a station clock on a website via SVG
+test_files: []