survivalkit 0.1

data/templates/project/sources/pie/site/pie-wp-theme/search.php

@@ -0,0 +1,24 @@
+<?php
+
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2010 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) { die(); }
+
+// NOTE: this file is here for compatibility reasons - active templates are in the posts/ dir 
+
+cfct_posts();
+
+?>

data/templates/project/sources/pie/site/pie-wp-theme/sidebar.php

@@ -0,0 +1,24 @@
+<?php
+
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2010 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) { die(); }
+
+// NOTE: this file is here for compatibility reasons - active templates are in the sidebar/ dir 
+
+cfct_sidebar();
+
+?>

data/templates/project/sources/pie/site/pie-wp-theme/sidebar/sidebar-default.php

@@ -0,0 +1,68 @@
+<?php
+
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2010 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) { die(); }
+if (CFCT_DEBUG) { cfct_banner(__FILE__); }
+/*
+?>
+
+<div id="sidebar">
+	<div id="primary-sidebar">
+<?php
+$post = $orig_post;
+if ( !function_exists('dynamic_sidebar') || !dynamic_sidebar('Primary Sidebar') ) {
+?>
+		<div class="widget">
+			<h2 class="title">Archives</h2>
+			<ul>
+				<?php wp_get_archives(); ?>
+			</ul>
+		</div><!--.widget-->
+		<div class="widget">
+			<h2 class="title">Pages</h2>
+			<ul>
+				<?php wp_list_pages('title_li='); ?>
+			</ul>
+		</div><!--.widget-->
+<?php
+}
+?>
+	</div><!--#primary-sidebar-->
+	<div id="secondary-sidebar">
+<?php
+if ( !function_exists('dynamic_sidebar') || !dynamic_sidebar('Secondary Sidebar') ) { 
+?>
+		<div class="widget">
+			<h2 class="title">Search</h2>
+			<?php cfct_form('search'); ?>
+		</div><!--.widget-->
+		<div class="widget">
+			<h2 class="title">Tags</h2>
+			<?php wp_tag_cloud('smallest=10&largest=18&unit=px'); ?>
+		</div><!--.widget-->
+		<?php wp_register('<p>', '</p>'); ?> 
+		<p><?php wp_loginout(); ?></p>
+
+<?php
+}
+?>
+	</div><!--#secondary-sidebar-->
+</div><!--#sidebar-->
+
+<?php
+*/
+?>

data/templates/project/sources/pie/site/pie-wp-theme/single.php

@@ -0,0 +1,24 @@
+<?php
+
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2010 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) { die(); }
+
+// NOTE: this file is here for compatibility reasons - active templates are in the single/ dir 
+
+cfct_single();
+
+?>

data/templates/project/sources/pie/site/pie-wp-theme/single/single-default.php

@@ -0,0 +1,40 @@
+<?php
+
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2010 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) { die(); }
+if (CFCT_DEBUG) { cfct_banner(__FILE__); }
+
+get_header();
+
+cfct_loop();
+
+comments_template();
+
+?>
+
+<div class="pagination_single">
+	<span class="previous"><?php previous_post_link() ?></span>
+	<span class="next"><?php next_post_link() ?></span>
+</div>
+
+<?php 
+
+get_sidebar();
+
+get_footer();
+
+?>

data/templates/project/sources/pie/site/pie-wp-theme/style.css

@@ -0,0 +1,73 @@
+/*
+
+Theme Name: CSS3 PIE site theme
+Theme URI: http://css3pie.com
+Description: Theme for the css3pie.com website. Based on the Carrington JAM CMS theme framework (http://carringtontheme.com).
+Version: 1.0
+Author: Jason Johnston
+Author URI: http://lojjic.com
+
+// Original copyright:
+//
+// This file is part of the Carrington JAM Theme for WordPress
+// http://carringtontheme.com
+//
+// Copyright (c) 2008-2009 Crowd Favorite, Ltd. All rights reserved.
+// http://crowdfavorite.com
+//
+// Released under the GPL license
+// http://www.opensource.org/licenses/gpl-license.php
+//
+// **********************************************************************
+// 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. 
+// **********************************************************************
+
+NOTE: This file is not used in this theme but is included for WordPress theme expected format compatibility - it's standard to use the css/ dir for actual theme CSS in a Carrington-based theme.
+
+*/
+
+/* including for compatibility */
+
+/*
+.alignleft {
+	float:left;
+	margin-right:1em;
+	margin-bottom:1em;
+}
+.alignright {
+	float:right;
+	margin-left:1em;
+	margin-bottom:1em;
+}
+.aligncenter {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+}
+.wp-caption {
+	border: 1px solid #ddd;
+	text-align: center;
+	background-color: #f3f3f3;
+	padding-top: 4px;
+	margin: 10px;
+	*/
+/* optional rounded corners for browsers that support it *//*
+
+	-moz-border-radius: 3px;
+	-khtml-border-radius: 3px;
+	-webkit-border-radius: 3px;
+	border-radius: 3px;
+}
+.wp-caption img {
+	margin: 0;
+	padding: 0;
+	border: 0 none;
+}
+.wp-caption p.wp-caption-text {
+	font-size: 11px;
+	line-height: 17px;
+	padding: 0 4px 5px;
+	margin: 0;
+}*/

data/templates/project/sources/pie/sources/Angle.js

@@ -0,0 +1,36 @@
+/**
+ * Wrapper for angle values; handles conversion to degrees from all allowed angle units
+ * @constructor
+ * @param {string} val The raw CSS value for the angle. It is assumed it has been pre-validated.
+ */
+PIE.Angle = (function() {
+    function Angle( val ) {
+        this.val = val;
+    }
+    Angle.prototype = {
+        unitRE: /[a-z]+$/i,
+
+        /**
+         * @return {string} The unit of the angle value
+         */
+        getUnit: function() {
+            return this._unit || ( this._unit = this.val.match( this.unitRE )[0].toLowerCase() );
+        },
+
+        /**
+         * Get the numeric value of the angle in degrees.
+         * @return {number} The degrees value
+         */
+        degrees: function() {
+            var deg = this._deg, u, n;
+            if( deg === undefined ) {
+                u = this.getUnit();
+                n = parseFloat( this.val, 10 );
+                deg = this._deg = ( u === 'deg' ? n : u === 'rad' ? n / Math.PI * 180 : u === 'grad' ? n / 400 * 360 : u === 'turn' ? n * 360 : 0 );
+            }
+            return deg;
+        }
+    };
+
+    return Angle;
+})();

data/templates/project/sources/pie/sources/BackgroundRenderer.js

@@ -0,0 +1,381 @@
+/**
+ * Renderer for element backgrounds.
+ * @constructor
+ * @param {Element} el The target element
+ * @param {Object} styleInfos The StyleInfo objects
+ * @param {PIE.RootRenderer} parent
+ */
+PIE.BackgroundRenderer = PIE.RendererBase.newRenderer( {
+
+    boxZIndex: 2,
+    boxName: 'background',
+
+    needsUpdate: function() {
+        var si = this.styleInfos;
+        return si.backgroundInfo.changed() || si.borderRadiusInfo.changed();
+    },
+
+    isActive: function() {
+        var si = this.styleInfos;
+        return si.borderImageInfo.isActive() ||
+               si.borderRadiusInfo.isActive() ||
+               si.backgroundInfo.isActive() ||
+               ( si.boxShadowInfo.isActive() && si.boxShadowInfo.getProps().inset );
+    },
+
+    /**
+     * Draw the shapes
+     */
+    draw: function() {
+        var bounds = this.boundsInfo.getBounds();
+        if( bounds.w && bounds.h ) {
+            this.drawBgColor();
+            this.drawBgImages();
+        }
+    },
+
+    /**
+     * Draw the background color shape
+     */
+    drawBgColor: function() {
+        var props = this.styleInfos.backgroundInfo.getProps(),
+            bounds = this.boundsInfo.getBounds(),
+            el = this.targetElement,
+            color = props && props.color,
+            shape, w, h, s, alpha;
+
+        if( color && color.alpha() > 0 ) {
+            this.hideBackground();
+
+            shape = this.getShape( 'bgColor', 'fill', this.getBox(), 1 );
+            w = bounds.w;
+            h = bounds.h;
+            shape.stroked = false;
+            shape.coordsize = w * 2 + ',' + h * 2;
+            shape.coordorigin = '1,1';
+            shape.path = this.getBoxPath( null, 2 );
+            s = shape.style;
+            s.width = w;
+            s.height = h;
+            shape.fill.color = color.colorValue( el );
+
+            alpha = color.alpha();
+            if( alpha < 1 ) {
+                shape.fill.opacity = alpha;
+            }
+        } else {
+            this.deleteShape( 'bgColor' );
+        }
+    },
+
+    /**
+     * Draw all the background image layers
+     */
+    drawBgImages: function() {
+        var props = this.styleInfos.backgroundInfo.getProps(),
+            bounds = this.boundsInfo.getBounds(),
+            images = props && props.bgImages,
+            img, shape, w, h, s, i;
+
+        if( images ) {
+            this.hideBackground();
+
+            w = bounds.w;
+            h = bounds.h;
+
+            i = images.length;
+            while( i-- ) {
+                img = images[i];
+                shape = this.getShape( 'bgImage' + i, 'fill', this.getBox(), 2 );
+
+                shape.stroked = false;
+                shape.fill.type = 'tile';
+                shape.fillcolor = 'none';
+                shape.coordsize = w * 2 + ',' + h * 2;
+                shape.coordorigin = '1,1';
+                shape.path = this.getBoxPath( 0, 2 );
+                s = shape.style;
+                s.width = w;
+                s.height = h;
+
+                if( img.imgType === 'linear-gradient' ) {
+                    this.addLinearGradient( shape, img );
+                }
+                else {
+                    shape.fill.src = img.imgUrl;
+                    this.positionBgImage( shape, i );
+                }
+            }
+        }
+
+        // Delete any bgImage shapes previously created which weren't used above
+        i = images ? images.length : 0;
+        while( this.deleteShape( 'bgImage' + i++ ) ) {}
+    },
+
+
+    /**
+     * Set the position and clipping of the background image for a layer
+     * @param {Element} shape
+     * @param {number} index
+     */
+    positionBgImage: function( shape, index ) {
+        PIE.Util.withImageSize( shape.fill.src, function( size ) {
+            var fill = shape.fill,
+                el = this.targetElement,
+                bounds = this.boundsInfo.getBounds(),
+                elW = bounds.w,
+                elH = bounds.h,
+                si = this.styleInfos,
+                border = si.borderInfo.getProps(),
+                bw = border && border.widths,
+                bwT = bw ? bw['t'].pixels( el ) : 0,
+                bwR = bw ? bw['r'].pixels( el ) : 0,
+                bwB = bw ? bw['b'].pixels( el ) : 0,
+                bwL = bw ? bw['l'].pixels( el ) : 0,
+                bg = si.backgroundInfo.getProps().bgImages[ index ],
+                bgPos = bg.bgPosition ? bg.bgPosition.coords( el, elW - size.w - bwL - bwR, elH - size.h - bwT - bwB ) : { x:0, y:0 },
+                repeat = bg.imgRepeat,
+                pxX, pxY,
+                clipT = 0, clipL = 0,
+                clipR = elW + 1, clipB = elH + 1, //make sure the default clip region is not inside the box (by a subpixel)
+                clipAdjust = PIE.ieVersion === 8 ? 0 : 1; //prior to IE8 requires 1 extra pixel in the image clip region
+
+            // Positioning - find the pixel offset from the top/left and convert to a ratio
+            // The position is shifted by half a pixel, to adjust for the half-pixel coordorigin shift which is
+            // needed to fix antialiasing but makes the bg image fuzzy.
+            pxX = Math.round( bgPos.x ) + bwL + 0.5;
+            pxY = Math.round( bgPos.y ) + bwT + 0.5;
+            fill.position = ( pxX / elW ) + ',' + ( pxY / elH );
+
+            // Repeating - clip the image shape
+            if( repeat && repeat !== 'repeat' ) {
+                if( repeat === 'repeat-x' || repeat === 'no-repeat' ) {
+                    clipT = pxY + 1;
+                    clipB = pxY + size.h + clipAdjust;
+                }
+                if( repeat === 'repeat-y' || repeat === 'no-repeat' ) {
+                    clipL = pxX + 1;
+                    clipR = pxX + size.w + clipAdjust;
+                }
+                shape.style.clip = 'rect(' + clipT + 'px,' + clipR + 'px,' + clipB + 'px,' + clipL + 'px)';
+            }
+        }, this );
+    },
+
+
+    /**
+     * Draw the linear gradient for a gradient layer
+     * @param {Element} shape
+     * @param {Object} info The object holding the information about the gradient
+     */
+    addLinearGradient: function( shape, info ) {
+        var el = this.targetElement,
+            bounds = this.boundsInfo.getBounds(),
+            w = bounds.w,
+            h = bounds.h,
+            fill = shape.fill,
+            angle = info.angle,
+            startPos = info.gradientStart,
+            stops = info.stops,
+            stopCount = stops.length,
+            PI = Math.PI,
+            UNDEF,
+            startX, startY,
+            endX, endY,
+            startCornerX, startCornerY,
+            endCornerX, endCornerY,
+            vmlAngle, vmlGradientLength, vmlColors,
+            deltaX, deltaY, lineLength,
+            stopPx, vmlOffsetPct,
+            p, i, j, before, after;
+
+        /**
+         * Find the point along a given line (defined by a starting point and an angle), at which
+         * that line is intersected by a perpendicular line extending through another point.
+         * @param x1 - x coord of the starting point
+         * @param y1 - y coord of the starting point
+         * @param angle - angle of the line extending from the starting point (in degrees)
+         * @param x2 - x coord of point along the perpendicular line
+         * @param y2 - y coord of point along the perpendicular line
+         * @return [ x, y ]
+         */
+        function perpendicularIntersect( x1, y1, angle, x2, y2 ) {
+            // Handle straight vertical and horizontal angles, for performance and to avoid
+            // divide-by-zero errors.
+            if( angle === 0 || angle === 180 ) {
+                return [ x2, y1 ];
+            }
+            else if( angle === 90 || angle === 270 ) {
+                return [ x1, y2 ];
+            }
+            else {
+                // General approach: determine the Ax+By=C formula for each line (the slope of the second
+                // line is the negative inverse of the first) and then solve for where both formulas have
+                // the same x/y values.
+                var a1 = Math.tan( -angle * PI / 180 ),
+                    c1 = a1 * x1 - y1,
+                    a2 = -1 / a1,
+                    c2 = a2 * x2 - y2,
+                    d = a2 - a1,
+                    endX = ( c2 - c1 ) / d,
+                    endY = ( a1 * c2 - a2 * c1 ) / d;
+                return [ endX, endY ];
+            }
+        }
+
+        // Find the "start" and "end" corners; these are the corners furthest along the gradient line.
+        // This is used below to find the start/end positions of the CSS3 gradient-line, and also in finding
+        // the total length of the VML rendered gradient-line corner to corner.
+        function findCorners() {
+            startCornerX = ( angle >= 90 && angle < 270 ) ? w : 0;
+            startCornerY = angle < 180 ? h : 0;
+            endCornerX = w - startCornerX;
+            endCornerY = h - startCornerY;
+        }
+
+        // Normalize the angle to a value between [0, 360)
+        function normalizeAngle() {
+            while( angle < 0 ) {
+                angle += 360;
+            }
+            angle = angle % 360;
+        }
+
+        // Find the distance between two points
+        function distance( p1, p2 ) {
+            var dx = p2[0] - p1[0],
+                dy = p2[1] - p1[1];
+            return Math.abs(
+                dx === 0 ? dy :
+                dy === 0 ? dx :
+                Math.sqrt( dx * dx + dy * dy )
+            );
+        }
+
+        // Find the start and end points of the gradient
+        if( startPos ) {
+            startPos = startPos.coords( el, w, h );
+            startX = startPos.x;
+            startY = startPos.y;
+        }
+        if( angle ) {
+            angle = angle.degrees();
+
+            normalizeAngle();
+            findCorners();
+
+            // If no start position was specified, then choose a corner as the starting point.
+            if( !startPos ) {
+                startX = startCornerX;
+                startY = startCornerY;
+            }
+
+            // Find the end position by extending a perpendicular line from the gradient-line which
+            // intersects the corner opposite from the starting corner.
+            p = perpendicularIntersect( startX, startY, angle, endCornerX, endCornerY );
+            endX = p[0];
+            endY = p[1];
+        }
+        else if( startPos ) {
+            // Start position but no angle specified: find the end point by rotating 180deg around the center
+            endX = w - startX;
+            endY = h - startY;
+        }
+        else {
+            // Neither position nor angle specified; create vertical gradient from top to bottom
+            startX = startY = endX = 0;
+            endY = h;
+        }
+        deltaX = endX - startX;
+        deltaY = endY - startY;
+
+        if( angle === UNDEF ) {
+            // Get the angle based on the change in x/y from start to end point. Checks first for horizontal
+            // or vertical angles so they get exact whole numbers rather than what atan2 gives.
+            angle = ( !deltaX ? ( deltaY < 0 ? 90 : 270 ) :
+                        ( !deltaY ? ( deltaX < 0 ? 180 : 0 ) :
+                            -Math.atan2( deltaY, deltaX ) / PI * 180
+                        )
+                    );
+            normalizeAngle();
+            findCorners();
+        }
+
+
+        // In VML land, the angle of the rendered gradient depends on the aspect ratio of the shape's
+        // bounding box; for example specifying a 45 deg angle actually results in a gradient
+        // drawn diagonally from one corner to its opposite corner, which will only appear to the
+        // viewer as 45 degrees if the shape is equilateral.  We adjust for this by taking the x/y deltas
+        // between the start and end points, multiply one of them by the shape's aspect ratio,
+        // and get their arctangent, resulting in an appropriate VML angle. If the angle is perfectly
+        // horizontal or vertical then we don't need to do this conversion.
+        vmlAngle = ( angle % 90 ) ? Math.atan2( deltaX * w / h, deltaY ) / PI * 180 : ( angle + 90 );
+
+        // VML angles are 180 degrees offset from CSS angles
+        vmlAngle += 180;
+        vmlAngle = vmlAngle % 360;
+
+        // Add all the stops to the VML 'colors' list, including the first and last stops.
+        // For each, we find its pixel offset along the gradient-line; if the offset of a stop is less
+        // than that of its predecessor we increase it to be equal. We then map that pixel offset to a
+        // percentage along the VML gradient-line, which runs from shape corner to corner.
+        lineLength = distance( [ startX, startY ], [ endX, endY ] );
+        vmlGradientLength = distance( [ startCornerX, startCornerY ], perpendicularIntersect( startCornerX, startCornerY, angle, endCornerX, endCornerY ) );
+        vmlColors = [];
+        vmlOffsetPct = distance( [ startX, startY ], perpendicularIntersect( startX, startY, angle, startCornerX, startCornerY ) ) / vmlGradientLength * 100;
+
+        // Find the pixel offsets along the CSS3 gradient-line for each stop.
+        stopPx = [];
+        for( i = 0; i < stopCount; i++ ) {
+            stopPx.push( stops[i].offset ? stops[i].offset.pixels( el, lineLength ) :
+                         i === 0 ? 0 : i === stopCount - 1 ? lineLength : null );
+        }
+        // Fill in gaps with evenly-spaced offsets
+        for( i = 1; i < stopCount; i++ ) {
+            if( stopPx[ i ] === null ) {
+                before = stopPx[ i - 1 ];
+                j = i;
+                do {
+                    after = stopPx[ ++j ];
+                } while( after === null );
+                stopPx[ i ] = before + ( after - before ) / ( j - i + 1 );
+            }
+            // Make sure each stop's offset is no less than the one before it
+            stopPx[ i ] = Math.max( stopPx[ i ], stopPx[ i - 1 ] );
+        }
+
+        // Convert to percentage along the VML gradient line and add to the VML 'colors' value
+        for( i = 0; i < stopCount; i++ ) {
+            vmlColors.push(
+                ( vmlOffsetPct + ( stopPx[ i ] / vmlGradientLength * 100 ) ) + '% ' + stops[i].color.colorValue( el )
+            );
+        }
+
+        // Now, finally, we're ready to render the gradient fill. Set the start and end colors to
+        // the first and last stop colors; this just sets outer bounds for the gradient.
+        fill['angle'] = vmlAngle;
+        fill['type'] = 'gradient';
+        fill['method'] = 'sigma';
+        fill['color'] = stops[0].color.colorValue( el );
+        fill['color2'] = stops[stopCount - 1].color.colorValue( el );
+        fill['colors'].value = vmlColors.join( ',' );
+    },
+
+
+    /**
+     * Hide the actual background image and color of the element.
+     */
+    hideBackground: function() {
+        var rs = this.targetElement.runtimeStyle;
+        rs.backgroundImage = 'url(about:blank)'; //ensures the background area reacts to mouse events
+        rs.backgroundColor = 'transparent';
+    },
+
+    destroy: function() {
+        PIE.RendererBase.destroy.call( this );
+        var rs = this.targetElement.runtimeStyle;
+        rs.backgroundImage = rs.backgroundColor = '';
+    }
+
+} );