Most of the time, these bugs are a small oversight on my part, or just straight-up stupidity. I’m not perfect, and I’ll gladly fix these things as they come up. I don’t consider bugs in my code that people find to be an affront to my skill; in reality I find them an opportunity to get better at what I do.

Then you run into something like a bug using setInterval, and things just stop making sense.

Edit

Wow. I didn’t expect nearly as much traffic on this article as it ended up getting. I feel I should just put the learnings, work-arounds and the like up here, just to speed things up and to clarify.

I don’t like how setInterval works because if you lose the id reference, you’re hosed. That’s pretty much my gripe here. It’s just not a good implementation. Id’s that start at 1 (or 0!) and increment would at least allow a brute-force loop. A way to get back a collection of intervals in action would be swell. A proper ECMA addition to access the intervals in an object-esque manue would be awesome. Basically anything that didn’t require me to store every id somewhere for use later.

None of those options exist, and that’s the point of this article. The setInterval function returns something akin to a thread id, which you need to hold onto if you plan on killing the interval later (by passing it to clearInterval). It’s effectively a random integer, and the fact that there’s no way to access the intervals in any other way is silly to me. I will continue to think so until the logic can be explained in a way that makes sense.

The result of all of this? Don’t use setInterval if you can avoid it. If you can’t avoid it, pay close goddamned attention to when you use it so you don’t end up losing those all important references

Here are some ways to avoid losing the reference(s) / getting around setInterval:

Option one (original idea at the end of this post):

Use setTimeout with an external trigger of sorts. Gross, but it works well when you need to kill the function, and you may have left a closure / need to kill the function from somewhere else in your code.

//
//
var counter = 1, myTimeout;

function loopFunction () {
	if (counter < 5) {
		counter++;
		myTimeout = setTimeout(loopFunction, 5000);
	}
}

myTimeout = setTimeout(loopFunction, 50000);
//
//

Option 2:

Push the ids into an array, and use the array to kill them all later. Cleaner, but slightly more complex. Solves a slightly different issue to the last one.

//
//
var intervalArr = new Array();

function intervalOne () { alert ('foo');};
function intervalTwo () { alert ('bar');};

function killIntervals(){
	while(intervalArr.length > 0)
		clearInterval(intervalArr.pop());
};

// adds the intervals
intervalArr.push(setInterval(intervalOne, 2000));
intervalArr.push(setInterval(intervalTwo, 2000));

// removes them
killIntervals();
//
//

TLDR;

Click here to view the demo. Look at the source code, you’ll see what I’m demonstrating with this post. Be wiser for the fact and you’re done.

Some basics

So some basics on JavaScript for those that don’t know. review the following code:

//
//
var myVariable; // declare a blank variable

myVariable = 'Hello'; // sets the variable to 'Hello'
alert(myVariable); // will bring up an alert box that says 'Hello'

myVariable = 'Hi there'; // sets the variable to 'Hi there', overriding the old value
alert(myVariable); // will bring up an alert box that says 'Hi there'
//
//

That’s all basic JavaScript variable stuff. The reason I put this here is so you understand the concept that you can overwrite the value of a variable that was previously set. This is pretty much how variables work. It gets a little grey when assigning variable references but that’s not the point of this post.

Now there are two automating functions that people generally use: setInterval and setTimeout. I’m aware of web-workers and such, but I’m not getting into those here.

They generally work like this:

//
//
var myTimeout, myInterval; // blank variables

myTimeout = setTimeout(function(){ alert('Hello'); }, 5000); // After 5 seconds, alert 'Hello'
myInterval = setInterval(function(){ alert('Hi there'); }, 10000); // Every 10 seconds, alert 'Hi there'
//
//

Now in this example, I set up a function instance right in the timeout and interval assignments. You can also choose to to reference a function (not to be confused with a function call, which they dislike but you can work around), but for the sake of keeping my examples small I am using a function instance.

Basically setTimeout will call the function once when the timer (set in milliseconds) ticks, whereas setInterval will call the function every time the timer ticks. The reason You store them in variables is so you can use the clearTimeout and clearInterval functions. These are supposed to remove the timeout or interval from existence, stopping the functionality from happening (or happening again, whichever).

//
//
var myTimeout, myInterval; // blank variables

myTimeout = setTimeout(function(){ alert('Hello'); }, 5000); // After 5 seconds, alert 'Hello'
myInterval = setInterval(function(){ alert('Hi there'); }, 10000); // Every 10 seconds, alert 'Hi there'

clearTimeout(myTimeout); // kills the timeout, so it will never fire off
clearInterval (myInterval); //kills the interval, so it will never fire off.
//
//

Given this information, you may think that you can now go and do loads of timed stuff care-free! Well no, you can’t. You see I ran into an… oddity with setInterval and setTimeout. I couldn’t find any documentation showing this quirk, hence this blog post.

How I found the issue

So today, a colleague found a bug with a plugin I wrote. It’s a plugin that fades between slides. Pretty straight-forward. It has options to enable autoPlay, render paging buttons, etc. The autoplay functionality – that is, rotating between the slides – is being handled by setInterval.

Basically when it starts, I set an interval to rotate. If you skip slides (using a navigation) it stops the slider by clearing the interval. In theory, that is. Apparently somewhere down the line it stopped working, and I had to go hacking through the code to figure out what the hell was going on. As it works out I’ve found a rather odd issue with setInterval and setTimeout.

The issue manifested

Code:

//
//
var myInterval;

function alertOne() {
	alert('One');
}

function alertTwo() {
	alert('Two');
}

myInterval = setInterval(alertOne, 2000);
myInterval = setInterval(alertTwo, 3000);
//
//

<!-- snip -->
<a href="javascript:clearInterval(myInterval);">Kill stuff</a>
<!-- snip -->

Now given the idea of how variables should work, if you were to run this code, you would expect the first interval call to be overwritten by the second. That’s what I expected anyway. As it turns out, his is not the case. You see apparently it actually stacks the calls into the variable. Sort of like an array, but without any of the actual array properties or functionality.

Given that it stacks them, you would think that the clearInterval on the anchor would then remove both intervals. I mean they’re both attached to the variable, so it stands to reason that clearing the variable with clearInterval would sort it out right? Nope! It actually only clears the last interval set to it.

Don’t believe me? run it yourself, or click here for a running example. So I started trying to find ways of totally clearing it.

How about setting the variable to null? That won’t work because it treats the variable as a function reference, and not an instance of the interval system.

What about stacking the clearIntervals? That doesn’t work either. It only ever clears the last one that was assigned. The rest seem to become buried, and I haven’t found a way to surface them.

Oh and everything I just said about setInterval here? It also applies to setTimeout. I’m using setInterval though, because at least a timeout ends after the first call. That is, unless you made a self-replicating timeout function. You may as well use setInterval at that point unless you actually need to change the amount of time between calls, or you have external flags (see further down for an explanation of this).

So basically if you assign more than one interval or timeout to a variable, you’re screwed. You can’t clear them all with clearInterval, you can’t null the variable as it’s just a reference, and you can’t stack clearIntervals, because it doesn’t surface the previous assignments, even though they continue to run.

Solution?

Sadly there’s no sweet fix for this that I’ve found. Basically if you’re going to be using setInterval, make damned sure you use clearInterval before setting it again. If you don’t, you bury the old intervals and there’s no way to stop them from continuing..

A gross but possible solution would be to use a self-replicating setTimeout function that had an external flag that it could use to halt it’s loop.

Here’s a basic example:

//
//
var counter = 1;
var myTimeout;

function loopFunction () {
	if (counter < 5) {
		counter++;
		myTimeout = setTimeout(loopFunction, 5000);
	}
}

myTimeout = setTimeout(loopFunction, 50000);
//
//

If you do that, at least there’s a way to stop buried Timeouts. You don’t get such a luxury with setInterval.

This took me far too much time to figure out today, and either I missed a rather important class in JavaScript school* or not everyone knows about this. I went looking on the Googles, but didn’t come up with anything outlining the dangers of setInterval. Hopefully this will help someone out there. At the very least it’ll be a reminder to me to pay more attention when I use it.

* I don’t think there is an actual JavaScript school, even though that would be very, very useful.

Anyone that’s in the business will know that there are some common functional elements that you end up having to build with javascript: accordions, tabs, faders, sliders, lightboxes, filters, etc. Many of these items can bleed over into non-report sites, such as intranets or even public-facing sites.

Now some of those are fairly straight forward: an accordion is just a simple animate of a content section, repeat per title; tabs? Same deal. So you might be pretty inclined to just write the script adhoc on a project to project basis, copy and pasting it as you go. We were doing that at my work when I started on, but I found that we kept on having to add something, remove something, add hooks at certain points etc. In some cases we used someone else’s plugin to do these things, but we ran into some issues when it came to having to tweak the plugin for our needs.

As I was hired on as the senior front-ender, I was given the task of trying to help simplify things in our working process. This required me to dive right into plugin development, because one spot we were spending a lot of time was reinventing the wheel project to project. Even more time was spent debugging random plugins, or lashing them together.

As my place of employment works with jQuery, I wanted to develop something that could be maintained in-house, and would be a good starting point for repeating functionality. I ended up developing a jQuery plugin template, which I am sharing today.

Now, while I can’t feature the plugins I’ve made for my work here on my site (I’m pretty sure my they’d be less than impressed with that), I feel it’s fairly safe to distribute this template (boiler plate?) to the internets. It’s a compilation of a couple tutorials, as well as my own exploration into javascript. I’d be more than happy to give credit where it’s due, but I cannot remember where the heck I got some of the snippets I integrated. If anyone reading this happens to know, leave a comment and I’ll be more than happy to give said credit.

Below you will find my jQuery plugin template code in it’s entirety. I’m open to suggestions on how to improve it, so feel free to comment.

/*
*
    Name:      my.blank.plugin.js
    Purpose:   Shell to use for jQuery plugins
*/
(function ($) {
    // DONT FORGET TO NAME YOUR PLUGIN
    jQuery.fn.myPlugin = function (options, i) {
        // This handles multiple elements (like a class selector)
        if (this.length > 1) {
            var a = new Array();
            this.each(
                function (i) {
                    a.push($(this).myPlugin(options, i));
                });
            return a;
        }
        var opts = $.extend({}, $().myPlugin.defaults, options);

        /* PUBLIC FUNCTIONS */

        /* reInit is a flag that you can pass in case you don't
           want to remove everything during the destroy phase. */
        this.Destroy = function (reInit) {
            var container = this;
            var reInit = (reInit != undefined) ? reInit : false;
            $(container).removeData("myPlugin");
            // this removes the flag so we can re-initialize
        };

        this.Update = function (options) {
            opts = null;
            opts = $.extend({}, $().myPlugin.defaults, options);
            this.Destroy(true);
            return this.Create();
        };

        /* iteration will give you the index of the item
           in the selection. If not part of a loop, I'm
           prett sure this will be null. You've been warned. */
        this.Create = function (iteration) {

            // this stops double initialization
            if ($(container).data("myPlugin") == true)
                return this;

            // call a function before you do anything
            if (opts.beforeCreateFunction != null && $.isFunction(opts.beforeCreateFunction))
                opts.beforeCreateFunction(targetSection, opts);

             // reference to the object you're manipulating. To jQuery it, use $(container).
            var container = this;
            /* Failing that, you could just use 'this' without the var declaration,
               but if you are doing a lot of child looping, you'll be glad to have
               a reference to the target object. Also, performance improvements! */

            ////////////////////
            // DO STUFF HERE
            ////////////////////

            // Set a flag to show that this element has been plugin'd
            $(container).data("myPlugin", true);

            // call a function after you've initialized your plugin
            if (opts.afterCreateFunction != null && $.isFunction(opts.afterCreateFunction))
                opts.afterCreateFunction(targetSection, opts);

            /* Make sure to return, otherwise you can't store the element in a varaible,
               which means you can't use any of the plubic functions (you may not need
               them, but it's still good practice.) */
            return this;
        };

        /* Example of a public function, this can be used if you store
           this object in a variable.

           e.g. var foo = $("#target").myPlugin();
                foo.PublicFunction();
        */

        this.PublicFunction = function () {
            // do something
            myPrivatefunction();
        };

        /* PRIVATE FUNCTIONS */

        /* These aren't accessibly externally, and so can only
           be called from within the enclosure code. */

        function myPrivatefunction() { };

        /* arguably, you could wrap your private (or public)
        functions in an array such as the following: */

        // Private helper functions
        helper = {
            firstHelper: function () { /* do something */ },
            secondHelper: function (somevalue) { /* do something with the variable passed in */ }
        };

        //Public helper functions
        this.Helper = {
            FirstHelper: function () { /* do something */ },
            SecondHelper: function (somevalue) { /* do something with the variable passed in */ }
        };

        /* Personally, I don't see the point of doing this for
           anything OTHER than helper functions, I could, and
           probably am, wrong here... or at least ignorant. */

        // Finally
        return this.Create(i);
    };

    // DONT FORGET TO NAME YOUR DEFAULTS WITH THE SAME NAME
    jQuery.fn.myPlugin.defaults = {
        foo: "bar",
        something: "else",

        // Remember: these are function _references_ not function calls
        beforeCreateFunction: null,
        afterCreateFunction: null
    };
})(jQuery);

I’ve tried to comment the hell out of the code, so that it’s as straight-forward as possible. I assume that anyone that uses this will strip out the comments, as well as any of the functionality that isn’t required.

Please feel free to use this, but If you’d be so kind as to give me credit, that’d be swell. I can’t force you, but we’re all friends out here, aren’t we?

So as a result of my tooling around with WordPress, I’ve created two plugins for people to use.

RandomQuotr

In one of my older site lay­outs, I had a random quote dis­play­ing at the top of the page. The orig­i­nal logic was based very much on the Hello Dolly plugin that comes shipped with Word­Press. Even though I no longer use the func­tion within my layout, I still had the code and I felt that with a little revi­sion, this could be a psudo-​useful plugin.

So one morn­ing I did exactly that. Ran­domQuotr was born, and with it came the abil­ity to store all of the quotes within the WordPress data­base, as opposed to the PHP array that it started out as. Some more func­tion­al­ity was added to allow the selec­tion of spe­cific quotes.

PostDivider

I was a big advo­cate for using “the_excerpt()” for my sites layout, because it allowed me to split up my con­tent and work around my theme. the prob­lem is that using “the_excerpt()” sucks for many reasons:

1. The field is HTML only.
2. The field is tiny and cannot be re-​sized.
3. It requires you to break up your most in a less than stel­lar way.

Enter Post­Di­vider.

Based on an old post of mine, Post­Di­vider allows the user to get the con­tent before and after the <!–MORE–> tag sep­a­rately. With Post­Di­vider, hooks are pro­vided to allow the Theme to dis­play the text directly (echo­ing it), or return­ing the con­tent as a value from the func­tion. If no <!–MORE–> tag is pro­vided, it will return the_excerpt() and the_content() respectively.

So far those are the only ones I’ve developed. I’ve got a couple ideas for more, when I get around to building my portfolio and the like.

I’ve also created a page that lists all of the plugins I have developed. They’re also hosted over on the wordpress.org plugins directory if you want to keep watch there.

I’m always looking for feedback or suggestions, so feel free to email me or leave a comment.

When I developed the theme I am currently using, I searched high and low for something I could steal take inspiration from. The funny thing is that most people don’t even know where the colour swapper is on my site. So few in fact that I had to add a caption to it to help make it a little more obvious.

In any case I felt that I would share the method I used to create the swapping functionality on my website. I’m aware that most of it can be figured out with a little imagination and some source viewing, but I think that going through it step by step is more helpful.

UPDATE – 10/09/2008 - In record time, a second pair of eyes looking at this has managed to refine the process. Thank you Bart for pointing out that if the CSS files are named the same as the Title attribute of the Anchor, then you can drop the whole If statement. I’ve updated the tutorial accordingly

Table of contents

• The idea
• Before we begin
• Setting up our files
• Setting up the CSS files
• A dash of PHP
• The basic markup
• The JavaScript
  • Importing the required files
  • Adding functionality
• Pulling it all together
  • Flow
• Conclusion

The idea

So you want to build a colour swapper? Easy as pie. You want to do it without causing a postback and sustains itself throughout the navigation? That’s a little more tricky, and what I wanted to do myself.

What, you’re too lazy to figure this out for yourself? No problem. Read on and be merry.

Before we begin

A few words before we begin:

• I am not a master of JavaScript, let alone JQuery. I’m not a novice, but I am in no way a master of the language. There are probably many ways in which to improve my methods here. I’m going to take another crack at them and see what I can come up with. I’ll update the code to this post If I come up with anything.
• In addition to the last note, I’m not going to explain how JQuery works. they do a fine job on their own. If you don’t understand it, I suggest you take some time and become familiar with it.
• This whole solution rides on the idea that your users allow JavaScript and Cookies. If the Cookies are disabled, the styles will still change, but will not persist between page refreshes/navigation. If JavaScript is disabled, nothing will work because I have not yet implemented a postback-friendly alternate. If I find myself with time I’ll do this as well and update this post.
• This whole tutorial is based on the idea that you are applying this to a WordPress theme. If you’re using something else, you’ll need to alter this as you need.
• I have noticed that in some browsers, the swapping is not instant, and you may notice somewhat of a flicker. In my case the colours go away, and then the new ones are applied. Some browsers do not do this. I have no idea why this happens.

Setting up our files

For this solution we’re going to need to get some files from the JQuery website (the latest JQuery build), and create some files in our Theme folder.

You are going to need to make a JavaScript folder – I called mine “js” – and multiple CSS files. One will be a core style sheet that contains all of the universal CSS styles, and then alternate sheets that contain the CSS that is swapped around.

Example setup:

• THEME FOLDER
  • style.css
  • Yellow Version.css
  • Red Version.css
  • Blue Version.css
  • Green Version.css
  • JS FOLDER
    • jquery.js
    • functions.js

The rest of this example will assume that you have that setup.

Setting up the CSS files

First off, you’re going to need some CSS files to play around with. Generally you would have a core css file that would contain all the styles that wouldn’t be affected by your swapper. Depending on how you use your swapper, this may or may not be the case. Some people want to totally alter the website with their swapper; I just wanted a colour change.

Note: I’m not going to paste all the CSS I used to format the actual tiles, because my layout requirements will be different than yours. Set the CSS code up however you need to make your selector HTML – we’ll see that in a bit – look right.

So you have your core css file (style.css for WordPress users). Do what you need to in that file and then put it away. We won’t be touching it very much. The only addition I put in my CSS files are the following:

.red {background-color:#FF3333;}
.yellow {background-color:#FBDC00;}
.green {background-color:#1FF900;}
.blue {background-color:#00CCFF;}

These four styles are in my core CSS file so that my swappers always have access to correct classes for them. What this means is that regardless of what CSS file is imported, the swapper tiles will always look the same.

Next up we have our swapping CSS files: Blue Version, Green Version, Red Version and Yellow Version.

Note: I use Yellow Version as my default, but that doesn’t come in for a little bit yet.

So in each one of these CSS files, I have the same selectors:

.specialBGColor {background-color:#FBDC00;}
a, .specialColourText, #left_bar .widget table th {color:#FBDC00;}
.specialTopBorder{border-top:20px solid #FBDC00;}

All of your swappable CSS files will have the same selectors with whatever colour differences you need. In my case The hex colours are going to change to whatever is appropriate for the file (yellow is #FBDC00, red is #FF3333, etc.) “specialBGColor” is basically a class I apply to anything that is going to have a swappable background. I also have a “speciallTopBorder” that does something similar, and some selectors for links and table headers to change their colours.

All of these swappable CSS files should be in the same directory. Since I am using WordPress my CSS files are all kept together in the same directory: the theme directory. I dislike the lack of separation but I’ll manage.

Once you’ve got all those set up we can move on to setting up the PHP functions

A dash of PHP

We need to add a little function to our functions.php file. The function will attempt to grab a value from the users cookie cache and return it. Pretty simple overall. In my case, if the cookie is not found, it returns a default string that is the URL to my yellow style sheet. As previously stated, the Yellow CSS file is the same.

Add the following to your functions.php file:

function getStyleCookie()
{
   if($_COOKIE["styleHref"] != null && $_COOKIE["styleHref"] != "")
   {
      echo $_COOKIE["styleHref"];
   }
   else
   {
      $url = bloginfo('template_url') + "/Yellow Version.css";
      echo $url;
   }
}

What this does is if it can get the cookies value – in this case “styleHref” cookie – this is explained in the JS – it will echo the value of the cookie. if it can’t it returns the default value of the Yellow Version.css location.

Note: I could have made the function a bit more universal by passing in the cookie name, but as I’m only using it for this one instance, I didn’t bother.

The basic markup

Alright lets set up the markup. Lets start with the header.

Locate the <head></head> section of your website (for WordPress users, this is usually the header.php file).

You’ll need to find where you have any current CSS files linked and paste the following over or after the CSS tags. I say over or after because depending how much of this you’re following, you may already have a core CSS file that you don’t want to remove.

<!-- THIS IS YOUR CORE CSS FILE. IGNORE THIS LINE IF YOU ALREADY HAVE THIS IN YOUR HEADER -->
<link rel="stylesheet" href="<?php bloginfo('stylesheet_url'); ?>" type="text/css"/>

<!-- some dynamic stuff that won't make any sense yet, but it will later -->
<?php if($_COOKIE["styleHref"] != null && $_COOKIE["styleHref"] != "") : ?>
   <link id="altsheet" rel="stylesheet" href="<?php echo $_COOKIE["styleHref"]; ?>" type="text/css"/>
<?php else : ?>
   <link id="altsheet" rel="stylesheet" href="<?php bloginfo('template_url'); ?>/Yellow Version.css" type="text/css"/>
<?php endif; ?>

What this does: try and get the URL to the currently used CSS file and render that CSS file. If nothing can be found, default to the Yellow Version style sheet. This may seem repetitive given that the functions.php code we put in also compensates for a lack of cookie. I’m one for having backup plans, and this was mine. If you don’t like it, you can simply remove the entire else section.

Next up is the actual swapper markup. I’m going to paste a simplified version of mine, because as I stated before, your swapper will look different than mine. As long as the base HMTL is the same, this solution works. how you style things up is totally up to you.

<div id="colour_swapper">
   <ul>
      <li>
         <a href="javascript:;" class="green" title="Green Version">Swap to green</a>
      </li>
      <li>
         <a href="javascript:;" class="yellow" title="Yellow Version">Swap to yellow</a>
      </li>
      <li>
         <a href="javascript:;" class="blue" title="Blue Version">Swap to blue</a>
      </li>
      <li>
         <a href="javascript:;" class="red" title="Red Version">Swap to red</a>
      </li>
   </ul>
</div>

The important parts to this are two-fold.

First, the ID of the DIV element is going to be used in the JavaScript. I’m aware that the DIV isn’t really needed, but as I said, this is a simplified version of what I’m using, and as such I’ve actually stripped out additional elements contained in the DIV.

The second thing is the title of the ANCHOR items. The title will be used in the JavaScript to determine what CSS file to get.

Note: I’m aware that having a href of ‘javascript:;’ is a bad practice. In reality the href should offer a link that would manually post back the page, and have PHP  code that would look for that action and set the cookie that way. Doing so would allow for the swapper to work when JavaScript is disabled.

The JavaScript

Importing the required files

This is where everything is tied together and starts working.

First off we need to import some JS files. This solution imports JQuery, as well as a functions.js file that I created in a sub directory of my Theme folder called “js”. This was explained in the Setup section, but I’m still reiterating.

First we need to add a bit more markup within our <head></head> sections:

<script type="text/JavaScript" src="<?php bloginfo('template_url'); ?>/js/jquery.js"></script>
<script type="text/javascript">
   var templateUrl = "<?php bloginfo('template_url'); ?>";
</script>
<script type="text/JavaScript" src="<?php bloginfo('template_url'); ?>/js/functions.js"></script>

What we’re doing here:

1. Importing the JQuery framework.
2. Setting a JavaScript variable that contains the template_url value from WordPress. This makes life easier when we get to the actual cookie setting.
3. Importing our functions.js file that will contain all of our functionality.

Note: I’m not a JavaScript expert, and part of me thinks that there should be a way to pass in the template URL to the functions.js import call. I don’t know and if someone can comment on this and explain, I’d be more than happy to refine my work.

Next up we need to add some functionality to the functions.js file!

Adding functionality

I’ll pase the code first and then explain it:

var $j = jQuery.noConflict();

$j(document).ready(function(){
   $j("#colour_swapper a").click( function(){
	var style_title = $j(this).attr("title");
	var style_href= "";
	var altSheet = $j("#altsheet");

	altSheet.attr({"href":templateUrl +"/" + style_title+".css"});

	style_href = altSheet.attr("href");

	var date = new Date();
	date.setTime(date.getTime()+(1*24*60*60*1000));
	var expires = "; expires="+date.toGMTString();
	document.cookie = "styleHref="+style_href+"; expires="+date.toGMTString()+"; path=/";
   });
 });

What the hell is going on:

1. Set JQuery to no conflict mode by assigning it to a different variable. I had to do this because of other plugins I use on my site. I maintain that this is a good idea when you are working in a plugin-heavy framework like WordPress.
2. For every link found within the element with the id of colour_swapper attach a new click function
3. Set a variable to the value of the links title (Yellow Version, Green Version, etc)
4. Grab the element with the id of “altsheet” (in our case this is a link element in our header) and change it’s href value to the url of the new style sheet. This url is made up of the template URL and the name of the style sheet (title of the anchor)
5. Set a variable with the URL the new CSS file to be used.
6. Create a date variable, and set it to the future (exact day eludes me at the moment. Part of me thinks that it’s either 24 hours into the future, or 1000 days. I can’t honestly remember at this point).
7. Convert the date to a GMTString which is used in the creation of cookies.
8. Create a cookie, “styleHref”, that stores the URL of the style sheet used. This cookie is set to expire in the future, and will apply to all pages within the website (that’s what the “/” is for)

Whew! That took longer to explain than I thought.

Pulling it all together

So now that we’ve gone through all that, everything should work. To give you an idea on how it all comes together I’ll explain the general flow.

Flow

• While the page is loading, try and grab the cookie and set the secondary style sheet. If none is found, apply a default (Yellow Version)
• Import all of the JavaScript needed.
• User clicks on a style swapping link
• JavaScript figures out what style sheet to use
• Changes the secondary sheets href to the new CSS file
• Sets a cookie to store the URL of the new CSS file

Now if a user navigates to another page in your website, the first step will apply the change right off the bat.

Conclusion

I hope that this helps someone out there, and comments are more than appreciated to help improve the solution. I’ll try and refine the solution a little more when I have time.

Good luck and happy coding!

I myself am a fan despite it’s assault on the CPU and database. It’s fast, it’s simple, and so long as your website isn’t gaining huge traffic (or you’re paying peanuts for CPU usage and storage) than it’s a great selection. It’s fairly customizable, has a huge support and user base, and it’s just damned easy to use. I’ve been slowly getting more and more into customizing and extending what WordPress can do out of the box.There’s more in the code than people think.

Recently I a friend of mine ripped a strip off of me for only using summaries in my RSS feed. He told me that he, along with other net-savvy users, didn’t have time to get teased by RSS summaries.

UPDATE: As of December 3rd, 2008 I’ve turned this baby into a plugin! Check it out.

For those wishing to skip the lengthy buildup, here is a little table of contents:

• The Back Story
• Solution
• Explanation
• Installation and Usage
• Further Notes

The Back Story – To Summarize or not to Summarize

This is some what of a conundrum, as I want people to actually come to my site. On the flip side, I want people to read what I write. So I can force people to come to my site and gain page views, or I can increase my RSS readership. After careful consideration, I’ve opted to fix my RSS feed to display the entire content.

Here’s the issue: Until now, I’ve used ‘The Excerpt’ field in WordPress. Basically this allows me to have a pretty excerpt instead of 55 characters truncated with a “READ MORE PLEAZE!” I use the custom excerpt for the top part of the post; the preview if you will. The problem with this is that I had to rip out the first couple paragraphs from the post area, add some HTML to make sure it worked, and then post. The result looked pretty, but had some unexpected side-effects on the RSS.

As it turns out, when you decide to use the EXCERPT field, that excerpt will become the summary in the RSS. That’s all well and good, but what If you want to have the whole post? One would hope that it would stitch the Excerpt and the Post together, but alas this was not the case.

I turned to the <!–more–> tag to assist me.

What they don’t document about the more tag is pretty much all the bitchy parts of it. When you use the <!–more–> tag, you split the content, allowing for the excerpt to be defaulted to all the content preceding the tag. This is great, except for how my layout works. You see The top have is the Excerpt, and the bottom half is the rest of the post. Just using the_content wouldn’t work, because I would be repeating all the pre-more content.

I thought about maybe using an hr tag, or reworking my entire layout, but I dismissed those due to the complexity of the markup. My only option was to carve into WordPress itself. I first checked Google to see if anyone had come up against what I was facing. As it turns out people have asked the question, but no one has posted the answer.

I am fixing that right now.

Getting the Pre and Post <!–more–> content separately

Here is my solution, in full:

function the_formatted_pre_more_from_content ($body)
{
$returnVal = get_the_formatted_pre_more_from_content ($body);
if ($returnVal !== FALSE)
echo get_the_formatted_pre_more_from_content ($body);
else
the_excerpt();
}

function get_the_formatted_pre_more_from_content ($body)
{
$moreTag = ‘<!–more’;
$content = FALSE;

$morePos = stripos($body, $moreTag);
if ($morePos !== FALSE || $morePos > -1)
$content = substr($body, 0, $morePos);
else
return FALSE;

$content = apply_filters(‘the_content’, $content);
$content = str_replace(‘]]>’, ‘]]>’, $content);

return $content;
}

function the_formatted_post_more_from_content ($body)
{
echo get_the_formatted_post_more_from_content ($body);
}

function get_the_formatted_post_more_from_content ($body)
{
$moreTag = ‘<!–more’;
$content = FALSE;

$morePos = stripos($body, $moreTag);

if ($morePos !== FALSE || $morePos > -1)
{
$content = substr($body, $morePos + strlen($moreTag));
$morePos = stripos($content, ‘–>’); // reuse variable
if ($morePos !== FALSE || $morePos > -1)
$content = substr($content, $morePos + 3); // strip off rest of more tag
}
else
$content = $body;

$content = apply_filters(‘the_content’, $content);
$content = str_replace(‘]]>’, ‘]]&gt;’, $content);

return $content;
}

Explanation

The two important functions here are ‘get_the_formatted_pre_more_from_content’ and ‘get_the_formatted_post_more_from_content’. Long names, I know, but at least their mission is clear.

The other two functions ‘the_formatted_pre_more_from_content’ and ‘the_formatted_post_more_from_content’ pretty much add a bit of logic and echo the content automatically. I chose this naming structure and function structure to emulate what is already in WordPress (e.g. ‘the_content’ versus ‘get_the_content’).

Installation and Usage

To use this code, add it all to your functions.php file of your theme. I’m sure I, or some other enterprising person, could turn this into a plugin, but at the moment I don’t feel it’s warranted.

All of the functions take one parameter: $body.

When you call these functions you must be in The Loop.

example usage: <?php the_formatted_pre_more_from_content($post->post_content); ?>

explanation: This call will display the content preceding the <!–more–> tag.

example usage: <?php the_formatted_post_more_from_content($post->post_content); ?>

explanation: This call will display the content proceeding the <!–more–> tag.

Further Notes

UPDATE: As of December 3rd, 2008 I’ve turned this baby into a plugin! Check it out. I’ve also fixed the post_content bug!

Note the $post->post_content that is passed into the function. This exists automatically when you are in The Loop. This will pass all of the posts content to the function without any formatting. The only thing that isn’t straight text – conveniently – is the <!–more–> tag. As a result the content becomes fairly straight forward.

As of right now you must pass $post->post_content to the functions. I tried to do it without passing the value, and they don’t seem to pick up the value.

I opted for using a substring functionality as opposed to an array split function simply because it was 2 am when I finally got this going. I don’t know which is more efficient, so someone who is more knowledgeable in PHP can comment on this and state which is better.

I only search for ‘<!–more’ because according to the tag documentation, there is text that can follow the MORE that changes some functionality. As a result, I have an additional if statement in the get_post function that will detect for the end of the tag and substring the content again to trim that out.

I hope that this helps out some people who may be in a similar boat as I was.

Fast forward to my current job. I can assure you that there are a plethora of examples that I could choose from for the point I will be making here, but one strikes me as perfect. You see when we developers started there things were volatile, unstructured, and pretty much a mess. My now fellow programmers and myself were hired in the wake of a collection of other developers leaving for one reason or another. We were also thrust into a project pretty much from the moment we sat in our chairs.

This was all fine and good, and we build what we thought we were supposed to build. Three days before we showed it to the client, we went through a run-through with the manager, only to find out that what we built was not what the client wanted. Well okay parts of it were, but for the most part it was off the mark. The result was months of us working grueling hours of overtime, wherein time became an abstract concept and my world knew nothing but code.

What the hell happened?

We didn’t have a process.

We built what we were told to build at the start, but things changed. The functional spec. was updated and we were never told. On the flip side, we also never went looking. Communication was sub-par at best, and the short of it is that there was enough blame for everyone.

We thought we had a process, but the debacle that we ran headlong into demonstrated that whatever process was in place either wasn’t working or was never initiated. The result was everything blowing up in our face. As it turns out, if you do not learn from this mistake, it will happen again and again. I could pull from more examples, but I’ll refrain… sort of.

I am on a new project, in fact I am the lead developer of said project. It’s my first time doing this and I’ll admit that it is a daunting task, but I set about doing my best. I was given a functional specification, which I thought odd because I’m pretty sure I’m the one that’s supposed to build that. I was told to add my section to it and that was that. I did so, to the best of my ability, with the information I had available to me.

It was okayed, and I started handing out tasks and the development cycle began.

Then I was told that the way things were supposed to work wouldn’t work that way anymore. This was after we had built stuff. This is generally a bad design move, because now any development that was already done now has to be reviewed and possibly scrapped. I updated the spec. again, and away we went. Then I realized that something wasn’t covered with the information I was given, so I asked a question. One question, I swear to God I only asked one but what was the end result? Another overhaul. Another attempt at the functional spec.

This has happened a couple times, and is not how the process should work. In a perfect world, the functional spec. is completely done before a line of code is written. The world is not perfect of course, and we have to make do with what we got, but damnit, I wasn’t about to go and take another stab at anything only to have it change on me again. So I went back to my college roots, and I made a decision:

I will make the process work again.

How can I do that though, when everything has apparently been thrown to the wind? It’s easier than I thought… well sort of. It still requires effort, but I’d rather expend the effort where I did fixing the process then rebuilding anything three times.

I sat down with my other main developer, and we went through everything. We went through every aspect of the functional spec, screen designs, and data sources, and figured out how it all works. We asked all the ‘hows’ and ‘what ifs’ as well as all of the ‘what the hells’ that subsequently came up. We went through every resource, created or not, and decided what was needed, what information had to be stored, etc.. We created use cases for the complex cases, and walked through more processes then I would care to count.

The end result? I spent ten hours (minimum) in a board room with a print-enabled white board and wrote everything down. I’m pretty sure we have at least 15 printouts of notes and questions and diagrams and use cases which helped clear up the utter ambiguity that surrounded the project. They get it now, and so do I. It’s no longer a matter of “how does this work?” but a matter of “what’s the next task?” Yes I have to update the functional spec. again, but at least now I know what to add, and where. The document is finally useful, and the project is understood. The process exists once again.

I’ve also taken it upon myself to write all of those tasks down in a shared location, so that whoever is on the project can take on new tasks as the run out of their assigned ones. That way no one has the excuse for not knowing what is next.

So yes we lost a day of development, but we have saved ourselves days of effort of unneeded rebuild time. Do it right the first time, and you’ll save time later.

On a side note, Sorry Mr. Miller turns out you were write all along about Analysis. My Bad.

As it turns out, customizing a Wiki Library to do anything isn’t just difficult, it’s not even a chore. It’s a goddamn mission of epically frustrating scale. Let’s start off with some over-all items:

1. I needed to create custom columns, some of which looked at lists.
2. I needed to create a content type that was based off of the Wiki content type.
3. I needed to customize the Wiki library to have said content type.
4. I needed to add custom-made web parts to the various views of the Wiki Library (History, Edit, etc)
5. I needed all of this to work through a feature

Where to start? Lets start from the bottom of the list, because as it turns out this was the easiest and where I started.

You want to edit those page layouts eh? Well have fun because as it turns out all of those files are system files, which means they’re on the hard-drive of the server and therefor shared. That means you can’t mess with one without causing a server-wide change. The solution? Copy those layout pages and rename them. Now add them to your feature. I’m not going to explain how to get the feature to deploy, that’s a different story all together.

That’s sweet! Now how do you make anything use those pages? Well in terms of all the little widgets (Versions tool, History Link, Incoming Link) You will have to build your own versions of those controls. Why? Well the URL of the pages that they point to are hard-coded. Simple enough to get around, though annoying as hell. Just to demonstrate, to the left is a screen shot of what SharePoints’ markup looks like just to recreate some of the controls in HTML. Seriously, that’s messed up. In the end each link was surrounded by two more tables. What the hell man?

Okay so you got all of the default pages redirected. What about when you edit an entry or make a new one? Those pages are tailored specifically for Wiki Pages (CreateWebPage.aspx) and so you’ll have to copy that one. As for redirecting it? Well you should be able to do it via an Event Receiver attached to the Feature that Installs the custom content type that this is all based from. please note my use of the word ‘should’ because I’m still stuck there.

Let’s move onto the library for a moment. Now I have not been able to replicate the Wiki library properly, without making my list type use the basetype of ’119′. As it turns out, this comes with a whole bunch of strings attached, like having hidden name columns and a lot of red-tape. I dare you to try and rename the “Name” column to anything with any sort of graceful code. I’ll leave that one there. For those that are wondering, the default Feature for Wiki Libraries is called “WebPageLib” or something of that nature. Try searching the 12 directory for the content type of Wikis. To find that, go looking for the ctypes Feature and look in there.

Creating the feature to house all of this turned out to be the easiest portion of it all, though all of the problems stemmed from it in some shape, way or form. I can’t bitch too much about the feature markup itself, because all it really lacks is some functionality that should… well really should just be there. I’ve had to rig extra code together just to get what I wanted, but read on and I’ll explain.

I managed to create the content type with little issues, though I had to add Remove references to the WikiPage content type (that does exist by the way, it’s just stored in the ‘_Hidden’ group which is why you can’t touch it via the site). Adding the new content type to the list template was fun too, because you have to do it via the feature, since Wiki libraries do not allow you to edit the Content Types of the list at all. Like I said, Wikis are sealed, and don’t like to play with the other kids.

The problems really started when I created the site columns. Just a note to everyone: if you ever feel like creating columns or content types, then using them, and then trying to remove them via a feature, good luck. SharePoint will not remove anything if it’s being used. Just a helpful tip there. This could be fixed via some EventReceiver code, but I won’t get into that.

Anyways, I had a column. It was a lookup column. It wanted to look at a specific list, so I gave it the list id (though to be honest this is a bad way to do it because what happens when you want to deploy this feature somewhere else?). I deployed the column, and it worked! Then I tried to use that column in a sub-site, which ended up failing miserably. Took me forever to find out that you cannot specify a web property in the feature. webid and scopeid, yes, but nothing generic (refer to my listId comment here). The solution to this was to add more custom EventReceiver code that would do this work for me. Which worked great until I moved the feature to another site.

This is where my night went bollocks.

I installed the feature onto another dev-site and activated it (all through stsadm). Worked fine. Then I tried to deactivate said feature, and it would just sit there. I could uninstall it fine, but when I deactivated it the process would just hang there and I’d be forced to end it via Task Manager. It took me 6 ruined dev-sites to realize that I was missing the lists that my lookups were pointing to. Apparently if you tie a lookup column to a list that doesn’t exist via code, it will cripple the server when you try and remove that column from any content types that it was attached to. When I say cripple, I’m not kidding. stsadm.exe ran up 50 Mb of resident memory, and 100% of the CPU. The best part was that no error would be logged, it would just hang there forever. I admit I toyed with the idea of letting it run all night and going home.

I kid you not, I laughed like a madman when I finally figured it out. I cannot explain why, but that’s just how it is. The lesson I learned from this really was that I shouldn’t have expected SharePoint to have any sort of intelligence sitting behind it, and code for stupidity. Anything you think SharePoint should probably just do probably doesn’t actually happen, or it happens with a hope and some duct tape.

Oh and for the record, I’m still stuck on how to change the Edit/New pages properly.