groundworkcss 0.2.2

data/vendor/assets/javascripts/groundworkcss/components/modals.coffee

@@ -0,0 +1,46 @@
+###
+ * Requires jquery.magnific-popup.js
+###
+$ ->
+  # single image
+  $(
+    ".modal.image, 
+     .modal[href*='.jpg'], 
+     .modal[href*='.jpeg'], 
+     .modal[href*='.gif'], 
+     .modal[href*='.png']"
+    ).magnificPopup(
+      type: 'image'
+    )
+  
+  # image gallery
+  $(".modal.gallery").magnificPopup(
+    delegate: 'a'
+    type: 'image'
+    image: 
+      titleSrc: 'title'
+    gallery: 
+      enabled: true
+  )
+
+  # inline content
+  $(".modal[href^='#']").magnificPopup(
+      type: 'inline'
+      mainClass: 'inline-modal'
+  )
+
+  # external content
+  $("a.modal[href^='http']").not(".image").not("[href*='.jpg']").not("[href*='.jpeg']").not("[href*='.gif']").not("[href*='.png']").magnificPopup(
+    type: 'iframe'
+    height: '100%'
+  )
+
+  # video content
+  $("a.video.modal[href^='http']").magnificPopup(
+    type: 'iframe'
+  )
+
+  # ajax content
+  $("a.modal[href]").not("[href^='#']").not(".image").not("[href^='http']").not("[href*='.jpg']").not("[href*='.jpeg']").not("[href*='.gif']").not("[href*='.png']").magnificPopup(
+    type: 'ajax'
+  )

data/vendor/assets/javascripts/groundworkcss/components/pagination.coffee

@@ -0,0 +1,128 @@
+$ ->
+  # initialize
+  limitPaginationItems()
+  $body = $ 'body'
+
+  # change active page
+  $body.on 'click', '.pagination ul > li:not(.next, .prev) a', (e) ->
+    $this = $ this
+    $('.pagination ul > li:not(.next, .prev)').removeClass('active')
+    
+    $this.parent('li').addClass('active')
+    # toggle previous button state
+    $prev = $('.pagination ul > li.prev') 
+    if $this.parent('li').hasClass('first')
+      $prev.addClass('disabled')
+    else
+      $prev.removeClass('disabled')
+      
+    # toggle next button state
+    $next = $('.pagination ul > li.next')
+    
+    if $this.parent('li').hasClass('last')
+      $next.addClass('disabled')
+    else
+      $next.removeClass('disabled')
+      
+    # adjust pagination
+    limitPaginationItems()
+    e.preventDefault()
+    
+    return false
+
+  # handle previous pagination button
+  $body.on 'click', '.pagination ul > li.prev:not(.disabled)', (e) ->
+    # enable next button
+    $('.pagination ul > li.next').removeClass('disabled')
+    el = $('.pagination ul > li.active')
+    if !el.hasClass('first')
+      # set previous page active
+      el.removeClass('active')
+      el.prev().addClass('active')
+      # adjust pagination
+      limitPaginationItems()
+      
+    # disable previous button if at first page
+    if $('.pagination ul > li.active').hasClass('first')
+      $(this).addClass('disabled')
+    e.preventDefault()
+    return false
+
+  # handle next pagination button
+  $body.on 'click', '.pagination ul > li.next:not(.disabled)', (e) ->
+    # enable previous button
+    $('.pagination ul > li.prev').removeClass('disabled')
+    el = $('.pagination ul > li.active')
+    if !el.hasClass('last')
+      # set next page active
+      el.removeClass('active')
+      el.next().addClass('active')
+      # adjust pagination
+      limitPaginationItems()
+      
+    # disable next button if at last page
+    if $('.pagination ul > li.active').hasClass('last')
+      $(this).addClass('disabled')
+      
+    e.preventDefault()
+    return false
+
+  # disable page jump for disabled pagination links
+  $body.on 'click', '.pagination ul > li.disabled a', (e) ->
+    e.preventDefault()
+    return false
+
+  return
+
+$(window).resize ->
+  # adjust pagination on resize
+  limitPaginationItems()
+
+# responsive pagination
+limitPaginationItems = ->
+  #process pagination lists
+  $('.pagination ul').each ->
+    pagination = $(this)
+    # pagination dimensions
+    visibleSpace = pagination.outerWidth() - pagination.children('li.prev').outerWidth() - pagination.children('li.next').outerWidth()
+    totalItemsWidth = 0
+    
+    pagination.children('li').each ->
+      totalItemsWidth += $(this).outerWidth()
+      return
+      
+    # hide pages that don't fit
+    pagination.children('li').not('.prev, .next, .active').hide()
+    visibleItemsWidth = 0
+    
+    pagination.children('li:visible').each ->
+      visibleItemsWidth += $(this).outerWidth()
+      return
+      
+    # adjust visible elements
+    while (visibleItemsWidth + 29) < visibleSpace && (visibleItemsWidth + 29) < totalItemsWidth
+      # show the next page number
+      pagination.children('li:visible').not('.next').last().next().show()
+      visibleItemsWidth = 0
+      
+      pagination.children('li:visible').each ->
+        visibleItemsWidth += $(this).outerWidth()
+        return
+        
+      if (visibleItemsWidth + 29) <= visibleSpace
+        # show the previous page number
+        pagination.children('li:visible').not('.prev').first().prev().show()
+        visibleItemsWidth = 0
+        
+        pagination.children('li:visible').each ->
+          visibleItemsWidth += $(this).outerWidth()
+          return
+          
+      # recalculate visibleItemsWidth
+      visibleItemsWidth = 0
+      
+      pagination.children('li:visible').each ->
+        visibleItemsWidth += $(this).outerWidth()
+        return
+        
+  return

data/vendor/assets/javascripts/groundworkcss/components/responsiveTables.coffee

@@ -0,0 +1,24 @@
+###
+ * Requires jquery.responsiveText.js
+###
+$ ->
+  # responsive tables
+  $('table.responsive').each (index, object) ->
+    $this = $ this
+    compression = 30
+    min = 8
+    max = 13
+    padding = 0
+    compression = parseFloat $this.attr('data-compression') || compression
+    min = parseFloat $this.attr('data-min') || min
+    max = parseFloat $this.attr('data-max') || max
+    padding = parseFloat $this.attr('data-padding') || padding
+    $(object).responsiveTable
+      compressor: compression
+      minSize: min
+      maxSize: max
+      padding: padding
+      
+    return
+    
+  return

data/vendor/assets/javascripts/groundworkcss/components/responsiveText.coffee

@@ -0,0 +1,38 @@
+###
+ * Requires jquery.responsiveText.js
+###
+$ ->
+  # responsive text
+  $('.responsive').not('table').each (index, object) ->
+    $this = $ this
+    
+    compression = 10
+    min = 10
+    max = 200
+    scrollTime = 650
+    scrollReset = 200
+
+    compression = parseFloat $this.attr('data-compression') || compression
+    min = parseFloat $this.attr('data-min') || min
+    max = parseFloat $this.attr('data-max') || max
+
+    $(object).responsiveText
+      compressor: compression
+      minSize: min
+      maxSize: max
+
+    $this.hover (->
+      difference = $this.get(0).scrollWidth - $this.width()
+      scrollTime = difference if difference > scrollTime
+      if difference > 0
+        $this.stop().animate
+          "text-indent": -difference
+        , scrollTime
+    ), ->
+      $this.stop().animate
+        "text-indent": 0
+      , scrollReset
+      
+    return
+    
+  return

data/vendor/assets/javascripts/groundworkcss/components/tabs.coffee

@@ -0,0 +1,20 @@
+$ ->
+  # tabs
+  $('body').on 'click', '.tabs > ul li a[href^=#], [role=tab] a', (e) ->
+    $this = $ this
+    unless $this.hasClass('disabled')
+      
+      if $this.parents('[role=tabpanel]').length > 0
+        tabs = $this.parents('[role=tabpanel]')
+      else
+        tabs = $this.parents('.tabs')
+        
+      tabs.find('> ul li a, [role=tab] a').removeClass('active')
+      $this.addClass('active')
+      tabs.children('div, [role=tabpanel]').removeClass('active')
+      tabs.children($this.attr('href')).addClass('active')
+      
+    e.preventDefault()
+    return false
+    
+  return

data/vendor/assets/javascripts/groundworkcss/components/tiles.coffee

@@ -0,0 +1,32 @@
+$ ->
+  $body = $('body')
+  # init and set active tile
+  $('.tiles').each ->
+    $this = $ this
+    $this.find('.tile').attr('role','button')
+    $this.find('.tile[data-value='+$this.find('input.value, select.value').val()+']').addClass('active')
+    
+    return 
+    
+  # tiles
+  $body.on 'click', '.tiles .tile', (e) ->
+    $this = $ this
+    unless $this.hasClass('disabled')
+      tiles = $this.parents('.tiles')
+      tiles.find('.tile').removeClass('active')
+      tiles.find('input.value, select.value').val($this.data('value')).change()
+      $this.addClass('active')
+      
+    e.preventDefault()
+    return false
+
+  # change active tile on callback
+  $body.on 'change', '.tiles input.value, .tiles select.value',  ->
+    $this = $ this
+    tiles = $this.parents('.tiles')
+    tiles.find('.tile').removeClass('active')
+    tiles.find('.tile[data-value='+$this.val()+']').addClass('active')
+    
+    return
+    
+  return 

data/vendor/assets/javascripts/groundworkcss/components/tooltips.coffee

@@ -0,0 +1,5 @@
+###
+ * Requires jquery.tooltips.js
+###
+$ ->
+  $('.tooltip[title]').tooltip() # tooltips

data/vendor/assets/javascripts/groundworkcss/index.js

@@ -0,0 +1,20 @@
+/*
+ *= require 'groundworkcss/plugins/jquery-modals'
+ *= require 'groundworkcss/plugins/jquery-responsiveTables'
+ *= require 'groundworkcss/plugins/jquery-responsiveText'
+ *= require 'groundworkcss/plugins/jquery-tooltip'
+ *= require 'groundworkcss/plugins/jquery.cycle2'
+ *= require 'groundworkcss/plugins/jquery.magnific-popup'
+ *= require 'groundworkcss/components/disabled'
+ *= require 'groundworkcss/components/dismissible'
+ *= require 'groundworkcss/components/equalizeColumns'
+ *= require 'groundworkcss/components/forms'
+ *= require 'groundworkcss/components/menus'
+ *= require 'groundworkcss/components/modals'
+ *= require 'groundworkcss/components/pagination'
+ *= require 'groundworkcss/components/responsiveTables'
+ *= require 'groundworkcss/components/responsiveText'
+ *= require 'groundworkcss/components/tabs'
+ *= require 'groundworkcss/components/tiles'
+ *= require 'groundworkcss/components/tooltips'
+ */

data/vendor/assets/javascripts/groundworkcss/libs/boxsizing.htc

@@ -0,0 +1,501 @@
+/**
+* box-sizing Polyfill
+* 
+* A polyfill for box-sizing: border-box for IE6 & IE7.
+* 
+* JScript
+* 
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published 
+* by the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Lesser General Public License for more details.
+* 
+* See <http://www.gnu.org/licenses/lgpl-3.0.txt>
+* 
+* @category  JScript 
+* @package   box-sizing-polyfill
+* @author    Christian Schepp Schaefer <schaepp@gmx.de> <http://twitter.com/derSchepp>
+* @copyright 2012 Christian Schepp Schaefer
+* @license   http://www.gnu.org/copyleft/lesser.html The GNU LESSER GENERAL PUBLIC LICENSE, Version 3.0
+* @link      http://github.com/Schepp/box-sizing-polyfill 
+*
+* PREFACE:
+*
+* This box-sizing polyfill is based on previous work done by Erik Arvidsson, 
+* which he published in 2002 on http://webfx.eae.net/dhtml/boxsizing/boxsizing.html.
+*
+* USAGE:
+* 	
+* Add the behavior/HTC after every `box-sizing: border-box;` that you assign:
+* 
+* box-sizing: border-box;
+* *behavior: url(/scripts/boxsizing.htc);`
+* 
+* Prefix the `behavior` property with a star, like seen above, so it will only be seen by 
+* IE6 & IE7, not by IE8+ who already implement box-sizing.
+*
+* The URL to the HTC file must be relative to your HTML(!) document, not relative to your CSS.
+* That's why I'd advise you to use absolute paths like in the example.
+*
+*/
+<component lightWeight="true">
+<attach event="onpropertychange" onevent="checkPropertyChange()" />
+<attach event="ondetach" onevent="restore()" />
+<attach event="onresize" for="window" onevent="update()" />
+<script type="text/javascript">
+//<![CDATA[
+
+var viewportwidth = (typeof window.innerWidth != 'undefined' ? window.innerWidth : element.document.documentElement.clientWidth);
+
+// Shortcut for the document object
+var doc = element.document;
+
+// Buffer for multiple resize events
+var resizetimeout = null;
+
+// Don't apply box-sizing to certain elements
+var apply = false;
+switch(element.nodeName){
+	case '#comment':
+	case 'HTML':
+	case 'HEAD':
+	case 'TITLE':
+	case 'SCRIPT':
+	case 'STYLE':
+	case 'LINK':
+	case 'META':
+	break;
+			
+	default:
+		apply = true;
+	break;
+}
+
+/*
+* update gets called during resize events, then waits until there are no further resize events, and finally triggers a recalculation
+*/
+function update(){
+	if(resizetimeout !== null){
+		window.clearTimeout(resizetimeout);
+	}
+	resizetimeout = window.setTimeout(function(){
+		restore();
+		init();
+		resizetimeout = null;
+	},100);
+}
+
+/*
+* restore gets called when the behavior is being detached (see event binding at the top),
+* resets everything like it was before applying the behavior
+*/
+function restore(){
+	if(apply){
+		try{
+			element.runtimeStyle.removeAttribute("width");
+			element.runtimeStyle.removeAttribute("height");
+		}
+		catch(e){}
+	}
+}
+
+/*
+* init gets called once at the start and then never again, 
+* triggers box-sizing calculations and updates width and height
+*/
+function init(){
+	if(apply){
+		updateBorderBoxWidth();
+		updateBorderBoxHeight();
+	}
+}
+
+/*
+* checkPropertyChange gets called as soon as an element property changes 
+* (see event binding at the top), it then checks if any property influencing its 
+* dimensions was changed and if yes recalculates width and height 
+*/
+function checkPropertyChange(){
+	if(apply){
+		var pn = event.propertyName;
+		if(pn === "style.boxSizing" && element.style.boxSizing === ""){
+			element.style.removeAttribute("boxSizing");
+			element.runtimeStyle.removeAttribute("boxSizing");
+			element.runtimeStyle.removeAttribute("width");
+			element.runtimeStyle.removeAttribute("height");
+		}
+		switch (pn){
+			case "style.width":
+			case "style.minWidth":
+			case "style.maxWidth":
+			case "style.borderLeftWidth":
+			case "style.borderLeftStyle":
+			case "style.borderRightWidth":
+			case "style.borderRightStyle":
+			case "style.paddingLeft":
+			case "style.paddingRight":
+				updateBorderBoxWidth();
+			break;
+		
+			case "style.height":
+			case "style.minHeight":
+			case "style.maxHeight":
+			case "style.borderTopWidth":
+			case "style.borderTopStyle":
+			case "style.borderBottomWidth":
+			case "style.borderBottomStyle":
+			case "style.paddingTop":
+			case "style.paddingBottom":
+				updateBorderBoxHeight();
+			break;
+		
+			case "className":
+			case "style.boxSizing":
+				updateBorderBoxWidth();
+				updateBorderBoxHeight();
+			break;
+		}
+	}
+}
+
+/* 
+ * Helper function, taken from Dean Edward's IE7 framework,
+ * added by Schepp on 12.06.2010.
+ * http://code.google.com/p/ie7-js/
+ *
+ * Allows us to convert from relative to pixel-values.
+ */
+function getPixelValue(value){
+	var PIXEL = /^\d+(px)?$/i;
+	if (PIXEL.test(value)) return parseInt(value);
+	var style = element.style.left;
+	var runtimeStyle = element.runtimeStyle.left;
+	element.runtimeStyle.left = element.currentStyle.left;
+	element.style.left = value || 0;
+	value = parseInt(element.style.pixelLeft);
+	element.style.left = style;
+	element.runtimeStyle.left = runtimeStyle;
+	
+	return value;
+}
+
+function getPixelWidth(object, value){
+	// For Pixel Values
+	var PIXEL = /^\d+(px)?$/i;
+	if (PIXEL.test(value)) return parseInt(value);
+	
+	// For Percentage Values
+	var PERCENT = /^[\d\.]+%$/i;
+	if (PERCENT.test(value)){
+		try{
+			var parentPaddingLeft = getPixelWidth(object.parentElement,object.parentElement.currentStyle.paddingLeft);
+			var parentPaddingRight = getPixelWidth(object.parentElement,object.parentElement.currentStyle.paddingRight);
+			var parentBorderLeft = getPixelWidth(object.parentElement,object.parentElement.currentStyle.borderLeft);
+			var parentBorderRight = getPixelWidth(object.parentElement,object.parentElement.currentStyle.borderRight);
+			
+			//var parentWidth = getPixelWidth(object.parentElement,(object.parentElement.currentStyle.width != "auto" ? object.parentElement.currentStyle.width : "100%"));
+			var parentWidth = object.parentElement.offsetWidth - parentPaddingLeft - parentPaddingRight - parentBorderLeft - parentBorderRight;
+			var value = (parseFloat(value) / 100) * parentWidth;
+		}
+		catch(e){
+			var value = (parseFloat(value) / 100) * element.document.documentElement.clientWidth;
+		}
+		return parseInt(value);
+	}
+	
+	// For EM Values
+	var style = object.style.left;
+	var runtimeStyle = object.runtimeStyle.left;
+	object.runtimeStyle.left = object.currentStyle.left;
+	object.style.left = value || 0;
+	value = parseInt(object.style.pixelLeft);
+	object.style.left = style;
+	object.runtimeStyle.left = runtimeStyle;
+	
+	return value;
+}
+
+function getPixelHeight(object, value){
+	// For Pixel Values
+	var PIXEL = /^\d+(px)?$/i;
+	if (PIXEL.test(value)) return parseInt(value);
+	
+	// For Percentage Values
+	var PERCENT = /^[\d\.]+%$/i;
+	if (PERCENT.test(value)){
+		try{
+			if(object.parentElement.currentStyle.height != "auto"){
+				switch(object.parentElement.nodeName){
+					default:
+						if(object.parentElement.currentStyle.height !== "auto"){
+							var parentPaddingTop = getPixelWidth(object.parentElement,object.parentElement.currentStyle.paddingTop);
+							var parentPaddingBottom = getPixelWidth(object.parentElement,object.parentElement.currentStyle.paddingBottom);
+							var parentBorderTop = getPixelWidth(object.parentElement,object.parentElement.currentStyle.borderTop);
+							var parentBorderBottom = getPixelWidth(object.parentElement,object.parentElement.currentStyle.borderBottom);
+							
+							var parentHeight = object.parentElement.offsetHeight - parentPaddingTop - parentPaddingBottom - parentBorderTop - parentBorderBottom;
+							//var parentHeight = getPixelHeight(object.parentElement,object.parentElement.currentStyle.height);
+
+							value = (parseFloat(value) / 100) * parentHeight;
+						}
+						else {
+							value = "auto";
+						}
+					break;
+					
+					case 'HTML':
+						parentHeight = element.document.documentElement.clientHeight;
+						if(parentHeight !== "auto"){
+							value = (parseFloat(value) / 100) * parentHeight;
+						}
+						else {
+							value = "auto";
+						}
+					break;
+				}
+				if(value !== "auto") value = parseInt(value);
+			}
+			else {
+				value = "auto";
+			}
+		}
+		catch(e){
+			value = "auto";
+		}
+		return value;
+	}
+	
+	// For EM Values
+	var style = object.style.left;
+	var runtimeStyle = object.runtimeStyle.left;
+	object.runtimeStyle.left = object.currentStyle.left;
+	object.style.left = value || 0;
+	value = parseInt(object.style.pixelLeft);
+	object.style.left = style;
+	object.runtimeStyle.left = runtimeStyle;
+	
+	return value;
+}
+
+
+/*
+ * getBorderWidth & friends
+ * Border width getters
+ */
+function getBorderWidth(sSide){
+	if(element.currentStyle["border" + sSide + "Style"] == "none"){
+		return 0;
+	}
+	var n = getPixelValue(element.currentStyle["border" + sSide + "Width"]);
+	return n || 0;
+}
+function getBorderLeftWidth() { return getBorderWidth("Left"); }
+function getBorderRightWidth() { return getBorderWidth("Right"); }
+function getBorderTopWidth() { return getBorderWidth("Top"); }
+function getBorderBottomWidth() { return getBorderWidth("Bottom"); }
+
+
+/*
+ * getPadding & friends
+ * Padding width getters
+ */
+function getPadding(sSide) {
+	var n = getPixelValue(element.currentStyle["padding" + sSide]);
+	return n || 0;
+}
+function getPaddingLeft() { return getPadding("Left"); }
+function getPaddingRight() { return getPadding("Right"); }
+function getPaddingTop() { return getPadding("Top"); }
+function getPaddingBottom() { return getPadding("Bottom"); }
+
+
+
+/*
+ * getBoxSizing
+ * Get the box-sizing value for the current element
+ */
+function getBoxSizing(){
+	var s = element.style;
+	var cs = element.currentStyle
+	if(typeof s.boxSizing != "undefined" && s.boxSizing != ""){
+		return s.boxSizing;
+	}
+	if(typeof s["box-sizing"] != "undefined" && s["box-sizing"] != ""){
+		return s["box-sizing"];
+	}
+	if(typeof cs.boxSizing != "undefined" && cs.boxSizing != ""){
+		return cs.boxSizing;
+	}
+	if(typeof cs["box-sizing"] != "undefined" && cs["box-sizing"] != ""){
+		return cs["box-sizing"];
+	}
+	return getDocumentBoxSizing();
+}
+
+
+/*
+ * getDocumentBoxSizing
+ * Get the default document box sizing (check for quirks mode)
+ */
+function getDocumentBoxSizing(){
+	if(doc.compatMode === null || doc.compatMode === "BackCompat"){
+		return "border-box";
+	}
+	return "content-box"
+}
+
+
+/*
+ * setBorderBoxWidth & friends
+ * Width and height setters
+ */
+function setBorderBoxWidth(n){
+	element.runtimeStyle.width = Math.max(0, n - getBorderLeftWidth() -
+		getPaddingLeft() - getPaddingRight() - getBorderRightWidth()) + "px";
+}
+function setBorderBoxMinWidth(n){
+	element.runtimeStyle.minWidth = Math.max(0, n - getBorderLeftWidth() -
+		getPaddingLeft() - getPaddingRight() - getBorderRightWidth()) + "px";
+}
+function setBorderBoxMaxWidth(n){
+	element.runtimeStyle.maxWidth = Math.max(0, n - getBorderLeftWidth() -
+		getPaddingLeft() - getPaddingRight() - getBorderRightWidth()) + "px";
+}
+function setBorderBoxHeight(n){
+	element.runtimeStyle.height = Math.max(0, n - getBorderTopWidth() -
+		getPaddingTop() - getPaddingBottom() - getBorderBottomWidth()) + "px";
+}
+function setBorderBoxMinHeight(n){
+	element.runtimeStyle.minHeight = Math.max(0, n - getBorderTopWidth() -
+		getPaddingTop() - getPaddingBottom() - getBorderBottomWidth()) + "px";
+}
+function setBorderBoxMaxHeight(n){
+	element.runtimeStyle.maxHeight = Math.max(0, n - getBorderTopWidth() -
+		getPaddingTop() - getPaddingBottom() - getBorderBottomWidth()) + "px";
+}
+function setContentBoxWidth(n){
+	element.runtimeStyle.width = Math.max(0, n + getBorderLeftWidth() +
+		getPaddingLeft() + getPaddingRight() + getBorderRightWidth()) + "px";
+}
+function setContentBoxMinWidth(n){
+	element.runtimeStyle.minWidth = Math.max(0, n + getBorderLeftWidth() +
+		getPaddingLeft() + getPaddingRight() + getBorderRightWidth()) + "px";
+}
+function setContentBoxMaxWidth(n){
+	element.runtimeStyle.maxWidth = Math.max(0, n + getBorderLeftWidth() +
+		getPaddingLeft() + getPaddingRight() + getBorderRightWidth()) + "px";
+}
+function setContentBoxHeight(n){
+	element.runtimeStyle.height = Math.max(0, n + getBorderTopWidth() +
+		getPaddingTop() + getPaddingBottom() + getBorderBottomWidth()) + "px";
+}
+function setContentBoxMinHeight(n){
+	element.runtimeStyle.minHeight = Math.max(0, n + getBorderTopWidth() +
+		getPaddingTop() + getPaddingBottom() + getBorderBottomWidth()) + "px";
+}
+function setContentBoxMaxHeight(n){
+	element.runtimeStyle.maxHeight = Math.max(0, n + getBorderTopWidth() +
+		getPaddingTop() + getPaddingBottom() + getBorderBottomWidth()) + "px";
+}
+
+
+/*
+ * updateBorderBoxWidth & updateBorderBoxHeight
+ * 
+ */
+function updateBorderBoxWidth() {
+	if(getDocumentBoxSizing() == getBoxSizing()){
+		return;
+	}
+	
+	var csw = element.currentStyle.width;
+	if(csw != "auto"){
+		csw = getPixelWidth(element,csw);
+		if(getBoxSizing() == "border-box"){
+			setBorderBoxWidth(parseInt(csw));
+		}
+		else{
+			setContentBoxWidth(parseInt(csw));
+		}
+	}
+
+	csw = element.currentStyle.minWidth;
+	if(csw != "none"){
+		csw = getPixelWidth(element,csw);
+		if(getBoxSizing() == "border-box"){
+			setBorderBoxMinWidth(parseInt(csw));
+		}
+		else{
+			setContentBoxMinWidth(parseInt(csw));
+		}
+	}
+
+	csw = element.currentStyle.maxWidth;
+	if(csw != "none"){
+		csw = getPixelWidth(element,csw);
+		if(getBoxSizing() == "border-box"){
+			setBorderBoxMaxWidth(parseInt(csw));
+		}
+		else{
+			setContentBoxMaxWidth(parseInt(csw));
+		}
+	}
+}
+
+function updateBorderBoxHeight() {
+	if(getDocumentBoxSizing() == getBoxSizing()){
+		return;
+	}
+	
+	var csh = element.currentStyle.height;
+	if(csh != "auto"){
+		csh = getPixelHeight(element,csh);
+		if(csh !== "auto"){
+			if(getBoxSizing() == "border-box"){
+				setBorderBoxHeight(parseInt(csh));
+			}
+			else{
+				setContentBoxHeight(parseInt(csh));
+			}
+		}
+	}
+
+	csh = element.currentStyle.minHeight;
+	if(csh != "none"){
+		csh = getPixelHeight(element,csh);
+		if(csh !== "none"){
+			if(getBoxSizing() == "border-box"){
+				setBorderBoxMinHeight(parseInt(csh));
+			}
+			else{
+				setContentBoxMinHeight(parseInt(csh));
+			}
+		}
+	}
+
+	csh = element.currentStyle.maxHeight;
+	if(csh != "none"){
+		csh = getPixelHeight(element,csh);
+		if(csh !== "none"){
+			if(getBoxSizing() == "border-box"){
+				setBorderBoxMaxHeight(parseInt(csh));
+			}
+			else{
+				setContentBoxMaxHeight(parseInt(csh));
+			}
+		}
+	}
+}
+
+
+// Run the calculations
+init();
+
+//]]>
+</script>
+</component>