Soliloquy was birthed out of countless hours of frustration when trying to deal with other slider plugins for WordPress. As I would hunt for an easy to use slider plugin for client projects, I kept having to revert to making my own custom slider plugins because the others simply didn’t cut it. Either the code was horrendous, the UI unfriendly, or they just plain didn’t work half the time as expected.

As I began surveying how I could remedy this situation, a thought occurred to me: “I wonder if other people share the same frustration as me”. You hear all the time that when a new slider plugin comes out, people say “Oh great, another slider plugin..” That type of attitude is symptomatic of a pandemic of bad slider plugins. 

Just think – when a new contact form plugin is created, nobody says “Oh great, another contact form plugin..”. Why? Because there are great contact form plugins like Gravity Forms that alleviate this symptom of thought. The same goes for SEO (Yoast), performance (W3TC), backups (BackupBuddy) and the list could go on. The type of thinking simply shifts from “Oh great, another X type of plugin..” to “Why do we need another X type of plugin?”. You see the difference? The former is out of frustration – the latter is out of perplexity.

My hope is that Soliloquy will change this way of thinking.

I’ve not been this excited about something that I’ve created in a long time. The reason why I am so excited? It’s going to be a game changer. The possibilities with Soliloquy are endless, and I’ve only touched the tip of the iceberg.

Features

I won’t go into much detail here about the features of Soliloquy (since you can view them from the actual Soliloquy site), but I will tell you that Soliloquy is incredibly efficient and resourceful. Soliloquy keeps everything to itself and doesn’t creep beyond it’s post type boundaries. It only loads what it needs when it needs it, and follows WordPress coding standards to the T. Its data security is absolutely the best of its class (the code is audited by Mark Jaquith) and it can be customized with a seemingly endless selection of hooks and filters.

But I think the best part about the plugin is the response from the WordPress community itself. I’ve not heard one negative thing yet about the plugin, and the response has been overwhelmingly positive, exciting and encouraging. People are finally beginning to get their slider plugin thirst quenched, and to watch that happen is a wonderful feeling.

Final Thoughts

Like I said earlier, Soliloquy is going to be a game changer. I’d love to hear your thoughts and responses on Soliloquy in the comments below! But before you do that, head on over to the site, check out all the features and consider purchasing a copy for yourself.

Humble Beginnings

October 3 years ago (October 2009) I was a sophomore in college at the wonderful Appalachian State University. I’ve always been pretty good with handling finances, but it just so happened that I was struggling to keep money in the bank. I was the stereotypical “poor” college student, yet unlike most college students who say they are poor, I really was.

I lived from paycheck to paycheck working at a local Cotillion teaching ballroom dancing and social etiquette alongside of the occasional carpet cleaning job. I remember many times eating macaroni and cheese for lunch and supper, and although I was still (and still am) blessed beyond all measure by Jesus, I hated the feeling of wondering if I would have enough money in the bank to get me by until the next paycheck. Jesus was always (and always is) faithful to provide me with money from somewhere (on multiple occasions I received checks in the mail from people who I still don’t know), but that didn’t mean I couldn’t work harder to provide.

So I decided to do something about it.

I did what lots of people do when they need money fast – I typed in “how to make money online” in Google and started searching.

I came across article writing and decided to give it a shot. I saw that it didn’t pay much, but with every article accepted I would get paid immediately. Immediate payment was nice, so one Sunday afternoon I sat down and began writing articles. I wrote 10 or 12 of them that afternoon, submitted them all and waited.

Two days later all but one of them were approved and I earned $27.

$27 wasn’t a lot, but it was $27 more than I had so I was incredibly excited. The next few months I powered through more than 75 articles on whatever topics intrigued me that day: singing, cleaning, poetry, sports, etc. I ended up making somewhere around $500 for all the articles I had written (including revenues from pageviews).

As Christmas break came, I sat down and really thought about the sustainability of this whole article writing and marketing thing. I came to the conclusion that the benefit I was receiving wasn’t worth the work I was putting into it (who could’ve seen that one coming?), so I went back to the drawing board.

I began to think to myself, “What if I had my own website where I wrote and marketed articles myself? Maybe then I would get some more money from pageviews and such.” Piece of cake, right?

I had always liked web stuff and had been fairly adept at fighting viruses on PCs, so I figured I would give this website thing a shot. Somehow I came across WordPress and decided it was the right way to go, especially with their “famous 5-minute installation”.

I went ahead and bought my first domain name and hosting and downloaded WordPress. I learned that I needed to setup a database and use FTP in order to upload WordPress to my server. Somehow (by the grace of God) I figured out how to create the database, but for the life of me could not figure out how to work FTP. Specifically, I had no clue what a “root” folder was, and so after 6 hours (yes, 6) of trying to upload WordPress, I quit.

I was so upset that I spent $60 for absolutely nothing and almost got sick to my stomach. $60 is a lot of money when you really don’t have much to begin with. I thought about getting a refund for the hosting, but the hubris in me (and the providence of God) stopped me from doing it.

Moving Forward

6 weeks later (around the middle fo February) I decided to give it another shot. Boone, NC had an abnormally cold and wintery season that year, and it just so happened that we were snowed in for a couple days in a row. I tried uploading WordPress and after 30 minutes I finally got it figured out (even though my first install was domain.com/wordpress). I was so excited I couldn’t help but pace the room and think of all the new possibilities for making some extra income.

I had been reading about SEO and niche sites when I was writing articles so I decided to put my knowledge to the test. I created my own niche site and started writing away. I got accepted for Google AdSense and thought I had it made.

That is, until a couple months later my AdSense account got banned for no apparent reason. I was floored. I had made only a handful of change, but it was crushing nonetheless (I successfully appealed the ban some months later to my surprise).

I then decided that I needed to go another route in order to make some extra money. I had become somewhat intrigued by tweaking my website design and had started to get the hang of CSS. I already knew some HTML from a class in high school, so I thought I would give development a try and see what would happen.

When I read about Thesis for WordPress and all of its awesome SEO capabilities and easy-to-use options in May 2010, I decided to purchase it and run with it. I had never used PHP before, but the concept of hooks and filters seemed easy enough. Use what you want, replace what you need.

Wrong.

No matter how many times people tell you web development is easy, learning a new language is still incredibly difficult. Learning syntax, nuances and best practices for a new programming language is likened to learning a spoken language. Sure, looking back now I wonder how I got so confused and frustrated, but that doesn’t change the fact that is was really tough in the beginning.

I can remember spending countless hours watching and reading tutorials on how to work with PHP and integrate it with HTML. Arrays, objects, functions, language constructs – none of it really made sense. I understood how to make something work, but I didn’t understand why it worked, and that just left me feeling like I was crawling in the dark all the time. Just in case you were wondering, that isn’t the most enjoyable place to be.

Summer rolled around and my dad knew I was trying to get into web development. He needed a website for his business, and so as a nice gift and gesture to get me started on my feet, he gave me $500 to build the website. I was so excited I could hardly stand it. 7 weeks later, I produced my first ever website (which considering it was my first website, I still don’t think it was all too bad ): http://glbuilding.com.

Even though 7 weeks is an incredibly long time to do a website, it really did take me that long to figure out how to make everything work. I was happy with the finished product, and so far the return on investment for my dad has been absolutely remarkable.

I was serving as the worship guy at a local church in Boone and got the privilege of doing their website for them as well. This time the website took half the time to make, and I really began to enjoy the development aspect of building websites. I still had no clue what half of PHP meant or how WordPress interacted with it, but one thing I knew for certain…

If I could get efficient at building websites, this could be a really good way to make extra money on the side.

The Ultimatum

So, on September 1, 2010, I officially created the business I now run today: Thomas Griffin Media. I got my EIN, went down to the Town Hall and filled out my application, gave them a check and had my business license. I can remember going by Cookout afterward and grabbing a milkshake. I couldn’t help but think of what the future would hold, and I knew it looked promising.

I’m a businessman by nature, so I believe that is really what propelled me to get contracts in the beginning – that and advertising on Google (which much to my surprise always had a positive ROI). From September to the end of the year, I made something like $5,000 doing whatever web design and development projects came my way. $5,000 was a ton of money for me in such a short period of time, so when I came home for Christmas break at the end of 2010 I sat down and made out a budget.

You see, I was engaged to be married September 2011. After a bunch of incredibly frustrating phone call interviews for jobs, I really, really hated the idea of going to work for “the man”. I had been through Dave Ramsey’s Total Money Makeover book and course (which I cannot recommend highly enough – I still use it to this day), so I knew that I needed to figure out a budget for my upcoming living expenses.

It wasn’t just about me anymore – I was going to have to provide for myself and my future wife. After digging through expenses and getting advice from my parents, I finally came up with a number – the amount of money I needed to make per month to get by.

Starting January 2011, I would do a 3 month trial run. I wrote out that if I made less than that number for any one of those months, I would quit web development and hunt for a job. I figured it this way – if I didn’t pursue web development, I would have enough money from those jobs during those months to get me buy until I found a job.

I didn’t miss that budget once during those 3 months and have yet to come under that budget to this day.

Growing

I really didn’t start to grasp WordPress until the spring of 2011. I had moved away from Thesis to the Genesis Framework (which I still use and highly recommend) and began to learn how the templating system in WordPress really worked. This proved to be vital in my growth as a developer.

But the most crucial piece of my development was learning about this function in PHP: print_r().

Yes, up until this past September I had never heard of or used functions such as print_r() and var_dump(). It is no wonder that PHP didn’t make sense to me. Before I learned the function print_r(), I had always wondered how in the world people knew what items were stored in particular variables.

Literally a whole new world opened up to me when I learned how to use print_r(). I finally understood how objects, arrays, loops, keys, values and more worked. And it didn’t take me long to put it into practice either.

TGM Plugin Activation was the first real application that I built after this enlightenment. While before I was PHP blind, now I saw at least somewhat clearly. With the help, encouragement and constant correction from Gary Jones, TGM Plugin Activation has blossomed into a really powerful piece of software for WordPress.

Part of growing pains is looking back at things you once did. I cringe at some of the things I made when I first started (and even some of the things on my own site), but I am ok with that because I did everything with integrity and honesty. I never tried to be someone that I wasn’t, and because of that, I can face the things I did in the past and point to the present.

Insights for You

The amount of knowledge I have learned from October 2011 until now has been exponential compared to my previous learning curve. I have been immensely blessed and continue to grow each and every day.

While I have grown tremendously in the past few years, I can honestly say that I still don’t know that much. I’m constantly humbled by those that are smarter than me, but that doesn’t mean that I can’t share some insight and wisdom from my own experiences in becoming a WordPress developer.

1. Don’t be afraid to look stupid. I know that I have had my pride handed to me on a cold dish an innumerable amount of times before, and I readily confess that it will happen in the future. But don’t ever let that stop you from learning. Learning takes time, study and plenty of questions – some of which may be more obvious to seasoned developers. Smug responses will come, but be quick to put them behind you – they were once in your shoes, too, at one time or another.
2. Ask plenty of questions. I ask questions all the time (and perhaps too much on some occasions). You won’t know until you ask, so you may as well ask anyway. You may find out that just asking will help you solve your own problems.
3. Be humble. Not that I am the paradigm of humility, but I have learned that a good dose of it is good for your soul. Don’t think of yourself higher than others. Remember that there is always someone who knows one more command, has created one more plugin, has a theme that loads .0005 seconds faster than yours, or has more efficient code than you. In humility, strive to become better and thank those that help you along the way.
4. You never stop learning. Don’t believe the lie that you “have arrived”. The fact you constantly have to push out bug fixes, tweaks and new versions of things should be a good reminder you still have room for growth.
5. Find some mentors. I’m indebted to a few people who (for whatever reason) decided to take some time and invest in me. Learn from your peers and benefit from the wisdom they can impart to you.
6. Seek a good name over everything else. Proverbs 22:1 says “A good name is to be chosen rather than great riches,
   and favor is better than silver or gold.” It is far better to have a good name than to build X number of junky sites or cheat clients out of X amount of dollars. To err is human, so inevitably you will make mistakes (like myself) and miss the mark – but don’t let that stop you from striving to have a good name among your peers, clients and other important people in your life.

It’s been good to reflect on the past couple years, and I really look forward to the years to come. I love my job as a WordPress developer and can’t wait to see what the future holds. I have lots to learn and plenty of room for growth, so lookout future – here I come.

Oh, and remember that first website I created? Last month it received over 86k pageviews and has an email list of over 7,000 people. Who would’ve guessed it?

The Aweber Comment Optin plugin works with, you guessed it, Aweber. It integrates seamlessly with Aweber’s API to subscribe users to a list of your choosing (their email and optionally their name). Beyond the difference in name, the API works a little bit differently in Aweber vs. MailChimp.

Aweber’s API requires OAuth authentication in order for the plugin to gain access to your account, list and subscriber information. OAuth is a security architecture that API platforms can use in order to get around users having to give away their login names and passwords. OAuth connects applications to API using authorization codes (or as I call them ‘tokens’). You will notice with the plugin that Aweber will require you to login and will give an OAuth authorization token before the plugin can access your data. Once you have done this one time, your authorization token will be good as long as you stay logged in. You must get a new authorization token anytime you have to log back in to Aweber and grant the plugin access to your account.

“But doesn’t Aweber’s official WordPress plugin do this already?” you might say. Yes, in a way it does, but even their own plugin doesn’t have the ability to check for pending/already subscribed users, which is a UX shame…and the code for the plugin is unorganized, sloppy, and has all those silly “pluggable” functions everywhere.

You really do have the opportunity to explode your email list by using this plugin, so don’t miss out on those valuable subscribers! You officially have no excuse!

Be sure to give me feedback and suggestions on how I can improve the plugin!

While part of that was on purpose (it’s been 18 months for most of them), I am now going to give email marketing a go on all of those niche sites (and even here on my own to demonstrate my new plugin).

A simple (or so it seems) way of gathering email addresses for your list is to provide an option to do so when commenting. This adds an easy way for your users to subscribe without having to enter extra information to optin to your list. My search came up empty for something like this that integrated with MailChimp (which is what I use for all my email lists), so I decided to write my own plugin to do what I need. Enter: MailChimp Comment Optin.

MailChimp Comment Optin adds just the functionality you need to grab email addresses when you user comments on your posts. Commenters can check a box in order to optin to an email list of your choosing. The process is double optin, so users will receive an activation email before they are confirmed.

In order to access your account, you will need to enter in a MailChimp API key for your account (which you can find under your account settings in the API Keys & Authorized Apps area). Once your API key has been entered and successfully validated, you will be able to select the list commenters should be subscribed to as well as some other options for customization.

The plugin checks for 3 different criteria and will display a different message for each:

1. ‘admin’ – if you are logged in as an administrator, a simple message is given to you instead of a checkbox (I’m guessing you don’t want to subscribe to your own list )
2. ‘pending’ – this message is displayed if the commenter has subscribed but has not yet activated their account
3. ‘subscribed’ – no checkbox is displayed but rather a message saying they are already subscribed to the blog

If none of these criteria are met, it is assumed that the current commenter is not subscribed to your list and thus a checkbox is displayed.

Below is a screenshot of the admin area (once you have entered your API key):

And if you want to see an example of what it looks like, well just look below my comment box to see.

Hope you enjoy the plugin and may your email list explode because of it!

It would be no lie to say that I have been incredibly busy this December. Traditionally December and January are my busiest months, and this year is no different. For the past few months, I’ve been working on an exciting new project that finally came to fruition called Cinch Templates – a landing page template solution built for WordPress.

What are Cinch Templates?

Cinch Templates are landing page templates for WordPress (with HTML versions as well) that are incredibly easy to use and setup, well designed and coded, SEO optimized, and mobile responsive.

This idea was birthed a few months ago out of my frustration to find a good landing page template that wasn’t insanely expensive or incredibly cumbersome to setup. The average user doesn’t want to pay a fortune for a one-page solution, nor do they want to edit HTML or use FTP to upload the template to their site. Heck, I’m a web developer and I feel the same way – so I decided to do something about it.

Cinch Templates utilize the power of WordPress to make landing page templates ridiculously easy to setup and use. Here’s a short rundown of some of the features:

• No HTML or FTP knowledge is needed once inside WordPress (no, really, you don’t need it)
• Installation and registration is as easy as clicking a file upload field and clicking a button – WordPress handles the rest for you using its own Filesystem class
• SEO settings can be customized using input fields
• You can choose color schemes right from the settings page
• You can upload and assign images right from the settings page using WordPress’ native media uploader
• You can craft your content using WordPress’ native WYSIWYG editor
• And of course, if you want to use HTML/CSS, there is an area to add custom scripts and styles
• Developers have plenty of hooks and filters to use to add/remove/modify content if they wish

One of the best things about Cinch Templates are their versatility. They can be used as standalone themes or can be included within existing WordPress themes where they are theme agnostic – you can use them within any existing WordPress theme or child theme that you desire (by using the Cinch Template Jetpack plugin). You can add and register as many Cinch Templates as you would like within your current theme, and these settings stay the same when changing from one theme to another. All you need to do is re-register the template(s) with the new, active WordPress theme and you are set to go.

If you head over to the Cinch Templates site now and enter in your email, you can get the first template, Classic, absolutely free of charge. It’s a classic, one-column landing page template design with 5 color schemes, the ability to upload a custom favicon and header and much, much more. And don’t worry – if you get lost, I’ve made an instructional video to help you out.

So if you need serious landing page templates that are easy to setup and use, consider Cinch Templates as your landing page template solution. You won’t be disappointed.

This child theme is packed with lots of theme options to customize your site. Specifically, you can:

• Choose between 8 different color styles with an intuitive UI (just click the color you want and you are set)
• Easily place social media buttons within your navigation menu
• Choose to add social media buttons to individual posts
• Customize the home page quote and link
• and so much more!

Not only does the theme come with these powerful theme options – it also comes pre-packaged with the Nivo Slider Pro plugin! That’s a $120 value for only $24.95! You simply cannot beat that.

Curtail also makes it simple to install the plugin with my automatic plugin activation class. Just follow the admin notices and you will have the Nivo Slider Pro plugin working in no time flat.

On top of this, the code base for this theme is incredibly well-tuned and defined. It is very well documented for  developers and is optimized for speed and performance.

So what are you waiting for? You should go grab a copy of Curtail for yourself today!

Today is great day for myself and for the WordPress community. I’ve been hard at work trying to solve a problem that has plagued theme authors for a long time – how to include or prompt users to automatically download, install and activate required (or necessary) plugins upon theme activation.

Well, now that is completely possible with a new class that I have built on top of a lot of WordPress APIs. With some help from Gary Jones, the TGM_Plugin_Activation class is now available for WordPress theme authors and users everywhere!

***UPDATE***

Version 2.0 now has an API for theme authors to hook into to use the class, eliminating the need to change the code within the class. Check out the details below!

Click here to download the class from Github

How It Works

The TGM_Plugin_Activation class works by taking a set a key => value pairs from a multidimensional array and processes them to do one of two things:

1. Automatically install a plugin that comes pre-packaged with the theme
2. Automatically download the .zip file from the WordPress Plugin Repository and install it

In either case, this new class can handle multiple instances of both, which means that you can include/prompt to download as many plugins as needed!

On theme activation, users are prompted with admin notices that certain plugins are required for the theme. Users can then click the links that take them to a page where forms are prepared for them to submit. If you just follow the instructions on the Github page without removing the default examples, your users would appear on a page that looks like this:

The UI is very familiar and intuitive because it follows suit with the rest of the WordPress admin UI. Users can then hit the submit button that installs the plugin. For plugins that come pre-packaged with the theme, they will see a screen that looks like this:

For plugins that are to be downloaded the WordPress Plugin Repository, they will see a screen that looks like this:

Seen these messages before? You probably have because the TGM_Plugin_Activation class uses the same methods as WordPress itself uses to download, install, upgrade and activate plugins.

How To Include the TGM_Plugin_Activation Class with Your Theme

Take a look at the following code (taken from the example.php file included with the class):

/**
 * Include the TGM_Plugin_Activation class.
 */
require_once dirname( __FILE__ ) . '/class-tgm-plugin-activation.php';

add_action( 'tgmpa_register', 'my_theme_register_required_plugins' );
/**
 * Register the required plugins for this theme.
 *
 * In this example, we register two plugins - one included with the TGMPA library
 * and one from the .org repo.
 *
 * The variable passed to tgmpa_register_plugins() should be an array of plugin
 * arrays.
 *
 * This function is hooked into tgmpa_init, which is fired within the
 * TGM_Plugin_Activation class constructor.
 */
function my_theme_register_required_plugins() {

	/**
	 * Array of plugin arrays. Required keys are name and slug.
	 * If the source is NOT from the .org repo, then source is also required.
	 */
	$plugins = array(
		/** This is an example of how to include a plugin pre-packaged with a theme */
		array(
			'name'     => 'TGM Example Plugin', // The plugin name
			'slug'     => 'tgm-example-plugin', // The plugin slug (typically the folder name)
			'source'   => get_stylesheet_directory() . '/lib/plugins/tgm-example-plugin.zip', // The plugin source
			'required' => false,
		),
		/** This is an example of how to include a plugin from the WordPress Plugin Repository */
		array(
			'name' => 'Edit Howdy',
			'slug' => 'edit-howdy',
		),
	);

	/** Change this to your theme text domain, used for internationalising strings */
	$theme_text_domain = 'tgmpa';

	/**
	 * Array of configuration settings. Uncomment and amend each line as needed.
	 * If you want the default strings to be available under your own theme domain,
	 * uncomment the strings and domain.
	 * Some of the strings are added into a sprintf, so see the comments at the
	 * end of each line for what each argument will be.
	 */
	$config = array(
		/*'domain'       => $theme_text_domain,         // Text domain - likely want to be the same as your theme. */
		/*'default_path' => '',                         // Default absolute path to pre-packaged plugins */
		/*'menu'         => 'install-my-theme-plugins', // Menu slug */
		'strings'      => array(
			/*'page_title'             => __( 'Install Required Plugins', $theme_text_domain ), // */
			/*'menu_title'             => __( 'Install Plugins', $theme_text_domain ), // */
			/*'instructions_install'   => __( 'The %1$s plugin is required for this theme. Click on the big blue button below to install and activate %1$s.', $theme_text_domain ), // %1$s = plugin name */
			/*'instructions_activate'  => __( 'The %1$s is installed but currently inactive. Please go to the <a href="%2$s">plugin administration page</a> page to activate it.', $theme_text_domain ), // %1$s = plugin name, %2$s = plugins page URL */
			/*'button'                 => __( 'Install %s Now', $theme_text_domain ), // %1$s = plugin name */
			/*'installing'             => __( 'Installing Plugin: %s', $theme_text_domain ), // %1$s = plugin name */
			/*'oops'                   => __( 'Something went wrong with the plugin API.', $theme_text_domain ), // */
			/*'notice_can_install'     => __( 'This theme requires the %1$s plugin. <a href="%2$s"><strong>Click here to begin the installation process</strong></a>. You may be asked for FTP credentials based on your server setup.', $theme_text_domain ), // %1$s = plugin name, %2$s = TGMPA page URL */
			/*'notice_cannot_install'  => __( 'Sorry, but you do not have the correct permissions to install the %s plugin. Contact the administrator of this site for help on getting the plugin installed.', $theme_text_domain ), // %1$s = plugin name */
			/*'notice_can_activate'    => __( 'This theme requires the %1$s plugin. That plugin is currently inactive, so please go to the <a href="%2$s">plugin administration page</a> to activate it.', $theme_text_domain ), // %1$s = plugin name, %2$s = plugins page URL */
			/*'notice_cannot_activate' => __( 'Sorry, but you do not have the correct permissions to activate the %s plugin. Contact the administrator of this site for help on getting the plugin activated.', $theme_text_domain ), // %1$s = plugin name */
			/*'return'                 => __( 'Return to Required Plugins Installer', $theme_text_domain ), // */
		),
	);

	tgmpa( $plugins, $config );

}

This may seem like a lot of code, but don’t let it scare you. Most of it is commenting to help you understand what each part does and how the API interacts with the class.

First you need to include the class for use within your functions.php file. This is done by the require_once line. You should amend the path so that it targets wherever you decide to place the class within your theme directory structure.

The crux of the API is the tgmpa_register() hook and the tgmpa() function. Your plugin information and configurations are added within a function that is added to the tgmpa_register hook. There are three variables for you to play with: $plugins, $config and $theme_text_domain.

The $plugins variables is required for you to fill out to include your plugins. The variable takes multiple arrays of arguments for your plugins. The keys ‘name’ and ‘slug’ are required for both pre-packaged and repo plugins. If you plugin is pre-packaged, the ‘source’ key is also required. The ‘required’ key is a boolean that will soon be used to determine whether your plugin is required or simply recommended. You can leave this out for now as it will not be active until a future update.

The $theme_text_domain is for localization. You set your own text domain here so that the strings used by the class can be localized along with your other theme text strings.

The $config variable allows you to set the theme text domain, the default absolute path to your pre-packaged plugins, the menu slug for the install plugins page, and an array of strings to customize admin notices and other messages to your theme users. Refer to the example.php file to learn how you can customize these for your theme.

A Look at What’s Inside

This automatic plugin installer class makes use of quite a few of WordPress’ own classes. Specifically, this class uses WP_Filesystem, Plugin_Upgrader, Plugin_Skin_Installer and WP_Error. This class also makes use of the plugins_api function as well for preparation for the plugin install and activation.

Unfortunately, none of these classes have extensive documentation (apart from WP_Error). Otto has a great tutorial on WP_Filesystem which I recommend you read get an understand of how to instantiate it. I will make a tutorial soon on how to use WP_Filesystem is correlation with other WordPress classes so you too can learn how to make applications like this one.

Questions? Comments? I’d love to have them! Please post any bugs you find or any questions that may arise when using this class because I would love to work them out. I believe this class has some great potential within the WordPress community, so please make sure you let everyone know about it!

Thomas

If you want to go ahead and download the source files, click this link here to download them.

Setting Up Our Directory Structure

The first thing we need to do is setup our directory and file structure. Make sure that your child theme already has a style.css and functions.php file as we will be using them later on in this tutorial. While in the root of your child theme, create a folder called lib. Within the lib folder, create another folder called admin. And finally, within the admin folder create a file called childthemename-theme-settings.php. Simply replace childthemename with your custom child theme’s name. Your structure should look similar to this (my child theme is called ctsettings):

Next, go to your child theme’s functions.php file and place this code right below the require_once( TEMPLATEPATH . '/lib/init.php' ); line:

require_once( CHILD_DIR . '/lib/admin/childthemename-theme-settings.php' );

Remember to replace childthemename with your custom child theme name!

Now that you have your structure in place, let’s begin building out our child theme options in our new file.

Setting Up the File Structure and Defining Constants

Let’s begin by setting up the file structure and defining any constants that we will use throughout our settings page (in this tutorial we will use just one constant). Copy and paste the following code into your childthemename-theme-settings.php file:

<?php
/**
 * CT Settings Theme Settings
 *
 * @package      CT Settings
 * @author       Thomas Griffin <http://thomasgriffinmedia.com/>
 * @copyright    Copyright (c) 2011, Thomas Griffin
 * @license      http://opensource.org/licenses/gpl-2.0.php GNU Public License
 *
 */

In order to follow best coding standards, we should make sure that we comment everything. In the commented section, simply change anywhere you see CT Settings to your custom child theme name. You should also change the author and copyright lines to reflect your own work.

Next we need to define our settings constant. Defining constants is beneficial because if we for some reason decide to change the name of our setting, we only have to change one line instead of searching through the entire document and changing every reference. Copy and paste the following code below your commented block:

/* Define our constants
------------------------------------------------------------ */

define( 'CTSETTINGS_SETTINGS_FIELD', 'ct-settings' );

This will define a constant to use for our settings field. Once again, change CTSETTINGS and ct-settings to your custom child theme’s name. Now that we have defined our settings field, we can easily grab options using Genesis’ genesis_get_option function:

genesis_get_option( 'childthemename_custom_option', CTSETTINGS_SETTINGS_FIELD );

Setting Up Default Options

Let’s go ahead and register our default options for our child theme settings. We always want to store our options in an array in order to optimize performance. Always remember to prefix your options with your child theme’s name! Copy and paste the following code into your childthemename-theme-settings.php file:

/* Setup default options
------------------------------------------------------------ */

/**
 * ctsettings_default_theme_options function.
 *
 * This function stores the default CT Settings theme options. It can be filtered using ctsettings_default_theme_options.
 *
 * @return $options, filtered by ctsettings_default_theme_options
 *
 * @since 1.0.0
 *
 */
function ctsettings_default_theme_options() {
	$options = array(
		'ctsettings_facebook_link' 	=> 0,
		'ctsettings_twitter_link' 	=> 0,
		'ctsettings_google_link' 	=> 0
	);
	return apply_filters( 'ctsettings_default_theme_options', $options );
}

Once again, remember to change out ctsettings to your child theme’s custom name. In this block of code, we are building out a function that will be used to register and store our child theme settings in the database. Our settings in this tutorial will be used to add Facebook Like, Tweet and Google+ buttons to our posts. On return, we have a filter setup so that default options can be added or removed using the ctsettings_default_theme_options filter. Now we are -almost- ready to register our settings and store our defaults in WordPress, but before we do this, we need to make sure that these options are properly sanitized using Genesis’ new sanitization class and filters.

Sanitizing Our Options

We always want our options to be secure, and in accordance to a security audit for Genesis, a new sanitization class was birthed that allows us to easily sanitize and secure our options for use. There are currently 4 sanitizing filters that can be utilized: one_zero, no_html, safe_html and requires_unfiltered_html. For this tutorial, we will only be using the one_zero filter for our checkboxes. Copy and paste the following code in your childthemename-theme-settings.php file:

/* Sanitize any inputs
------------------------------------------------------------ */

add_action( 'genesis_settings_sanitizer_init', 'ctsettings_sanitize_inputs' );
/**
 * ctsettings_sanitize_inputs function.
 *
 * This function accesses Genesis' sanitization class to sanitize all users inputs and options in the CT Settings settings area.
 *
 * @since 1.0.0
 *
 */
function ctsettings_sanitize_inputs() {
    genesis_add_option_filter( 'one_zero', CTSETTINGS_SETTINGS_FIELD, array( 'ctsettings_facebook_link', 'ctsettings_twitter_link', 'ctsettings_google_link' ) );
}

We are added our options to be sanitized into the genesis_settings_sanitizer_init action hook. The genesis_add_option_filter takes 3 parameters: $filter, $option and $suboption. The $filter option is the specific one we would like to use, which I listed previously. The $option parameter is for the settings field used in the sanitizer, which in this case is the one we defined at the beginning of our file, CTSETTINGS_SETTINGS_FIELD. The third parameter $suboption is an array of options that are tied to our settings field. Thus we have the code above! Now we can finally register and store our default options.

Registering, Storing and Restoring Our Default Settings

Copy and paste the following code below your previously pasted code in your childthemename-theme-settings.php file:

/* Register our settings and add the options to the database
------------------------------------------------------------ */

add_action( 'admin_init', 'ctsettings_register_settings' );
/**
 * ctsettings_register_settings function.
 *
 * This function registers the settings for use in the CT Settings theme settings area. It also restores default options when
 * the Reset button is selected.
 *
 * @since 1.0.0
 *
 */
function ctsettings_register_settings() {
	register_setting( CTSETTINGS_SETTINGS_FIELD, CTSETTINGS_SETTINGS_FIELD );
	add_option( CTSETTINGS_SETTINGS_FIELD, ctsettings_default_theme_options() );

	if ( genesis_get_option( 'reset', CTSETTINGS_SETTINGS_FIELD ) ) {
		update_option( CTSETTINGS_SETTINGS_FIELD, ctsettings_default_theme_options() );
		genesis_admin_redirect( CTSETTINGS_SETTINGS_FIELD, array( 'reset' => 'true' ) );
		exit;
	}
}

We hook this function into the admin_init hook. This function registers our settings and adds them into the database. We also add the reset option functionality into this function as well. We test if the reset button has been successfully submitted, and if so, we update our option field back to the defaults and refresh the page so that the defaults are present again (using the genesis_admin_redirect function). Remember to change CTSETTINGS_SETTINGS_FIELD to the constant you defined at the beginning of the file.

Adding Admin Notices for Updated Settings

Our last piece of overhead is to add in our admin notices when our settings are updated. This is the last piece of code needed before we actually begin to build out our page. After this, you will have laid the entire framework for your child theme options. Copy and paste the following code into your file:

/* Admin notices for when options are saved/reset
------------------------------------------------------------ */

add_action( 'admin_notices', 'ctsettings_theme_settings_notice' );
/**
 * ctsettings_theme_settings_notice function.
 *
 * This function displays admin notices when the user updates CT Settings' theme settings area.
 *
 * @since 1.0.0
 *
 */
function ctsettings_theme_settings_notice() {
	if ( ! isset( $_REQUEST['page'] ) || $_REQUEST['page'] != CTSETTINGS_SETTINGS_FIELD )
		return;

	if ( isset( $_REQUEST['reset'] ) && 'true' == $_REQUEST['reset'] )
		echo '<div id="message" class="updated"><p><strong>' . __( 'Settings reset.', 'genesis' ) . '</strong></p></div>';
	elseif ( isset( $_REQUEST['settings-updated'] ) && 'true' == $_REQUEST['settings-updated'] )
		echo '<div id="message" class="updated"><p><strong>' . __( 'Settings saved.', 'genesis' ) . '</strong></p></div>';
}

This function hooks into the admin_notices hook and alerts your users when they have either updated or reset their settings. This is a pretty straightforward function so I won’t go into great detail explaining it. Basically we check to make sure we are on the correct page, and if so, we then display messages based on the button the user has selected to update the child theme options. Now let’s go and build out our page!

Creating Your Child Theme Options Page

Finally we are ready to create our child theme’s options page. Copy and paste the following code into your file:

/* Register our theme options page
------------------------------------------------------------ */

add_action( 'admin_menu', 'ctsettings_theme_options' );
/**
 * ctsettings_theme_options function.
 *
 * This function registers the CT Settings settings page and prepares the styles, scripts and metaboxes to be loaded.
 *
 * @global $_ctsettings_settings_pagehook
 *
 * @since 1.0.0
 *
 */
function ctsettings_theme_options() {
	global $_ctsettings_settings_pagehook;
	$_ctsettings_settings_pagehook = add_submenu_page( 'genesis', 'CT Settings', 'CT Settings', 'edit_theme_options', CTSETTINGS_SETTINGS_FIELD, 'ctsettings_theme_options_page' );

	//add_action( 'load-'.$_ctsettings_settings_pagehook, 'ctsettings_settings_styles' );
	add_action( 'load-'.$_ctsettings_settings_pagehook, 'ctsettings_settings_scripts' );
	add_action( 'load-'.$_ctsettings_settings_pagehook, 'ctsettings_settings_boxes' );
}

By hooking into the admin_menu action hook, we are able to create our child theme options page. This page is created as a sub-menu page of the parent Genesis, as specified by the child theme standards document on StudioPress’ website. We setup a global variable called $_ctsettings_settings_pagehook so that we load our styles, scripts, metaboxes and forms only on our page. The last parameter of the add_submenu_page function is the callback function that will hold our form that displays and submits user inputted options.

Also in the function we are hooking into the load-$hookname action hook, which runs specified callback functions on the specific pagehook. For this tutorial, I have commented out the ctsettings_settings_styles action because we will not be using custom styles. If you wanted to add a custom stylesheet, you would uncomment that line and enqueue your admin stylesheet. Now we need to populate those callback functions that we just added to the action hooks.

Enqueuing Our Scripts

First we will populate the ctsettings_settings_scripts function. Copy and paste the following code into your file:

/* Setup our scripts
------------------------------------------------------------ */

/**
 * ctsettings_settings_scripts function.
 *
 * This function enqueues the scripts needed for the CT Settings settings page.
 *
 * @global $_ctsettings_settings_pagehook
 *
 * @since 1.0.0
 *
 */
function ctsettings_settings_scripts() {
	global $_ctsettings_settings_pagehook;
	wp_enqueue_script( 'common' );
	wp_enqueue_script( 'wp-lists' );
	wp_enqueue_script( 'postbox' );
}

This function simply enqueues the necessary scripts needed to make our page function like the Genesis theme option page functions. No more explanation necessary.

Adding Our Metaboxes to Our Child Theme Options Page

Next we need to populate our ctsettings_settings_boxes function. Copy and paste the following code into your file:

/* Setup our metaboxes
------------------------------------------------------------ */

/**
 * ctsettings_settings_boxes function.
 *
 * This function sets up the metaboxes to be populated by their respective callback functions.
 *
 * @global $_ctsettings_settings_pagehook
 *
 * @since 1.0.0
 *
 */
function ctsettings_settings_boxes() {
	global $_ctsettings_settings_pagehook;
	add_meta_box( 'ctsettings-social-box', __( 'CT Settings Social Sharing', 'genesis' ), 'ctsettings_social_metabox', $_ctsettings_settings_pagehook, 'main' );
}

This function adds our metabox into the system. Once again, we access the global variable $_ctsettings_settings_pagehook to ensure that we are doing this only on our child theme’s options page. In this tutorial, the add_meta_box function is taking 5 parameters: $id, $title, $callback, $page, and $context. We now need to populate our callback function ctsettings_social_metabox so that we can see our new metabox.

Creating and Displaying Our Metabox

Copy and paste this code into your file:

/* Add our custom post metabox for social sharing
------------------------------------------------------------ */

/**
 * ctsettings_social_metabox function.
 *
 * Callback function for the CT Settings Social Sharing metabox.
 *
 * @since 1.0.0
 *
 */
function ctsettings_social_metabox() { ?>

	<p><?php _e( 'Check any of the following if you want Facebook, Twitter or Google+ buttons for your posts.', 'genesis' ); ?></p>
	<table class="form-table ctsettings-social">
		<tbody>
			<tr valign="top">
				<th scope="row">
					<input type="checkbox" name="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_facebook_link]" id="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_facebook_link]" value="1" <?php checked( 1, genesis_get_option( 'ctsettings_facebook_link', CTSETTINGS_SETTINGS_FIELD ) ); ?> /> <label for="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_facebook_link]"><?php _e( 'Include a Facebook Like button on your posts?', 'genesis' ); ?></label>
				</th>
			</tr>
			<tr valign="top">
				<th scope="row">
					<input type="checkbox" name="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_twitter_link]" id="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_twitter_link]" value="1" <?php checked( 1, genesis_get_option( 'ctsettings_twitter_link', CTSETTINGS_SETTINGS_FIELD ) ); ?> /> <label for="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_twitter_link]"><?php _e( 'Include a Twitter Tweet button on your posts?', 'genesis' ); ?></label>
				</th>
			</tr>
			<tr valign="top">
				<th scope="row">
					<input type="checkbox" name="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_google_link]" id="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_google_link]" value="1" <?php checked( 1, genesis_get_option( 'ctsettings_google_link', CTSETTINGS_SETTINGS_FIELD ) ); ?> /> <label for="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[ctsettings_google_link]"><?php _e( 'Include a Google Plus button on your posts?', 'genesis' ); ?></label>
				</th>
			</tr>
		</tbody>
	</table>

<?php }

Phew, this is a giant chunk of code, but don’t be afraid. All we are doing is setting up our input fields to display our options. What is important is that you make sure that the constant CTSETTINGS_SETTINGS_FIELD matches the constant you set at the beginning of the file and the each individual option (such as ctsettings_google_link) matches the default options you set at the beginning of the file. Now, let’s make our screen one column to mimic how Genesis has its theme options and get our metabox displayed!

Setting the Screen to One Column and Displaying Our Options

Copy and paste the following function into your file. It will set the screen column to 1 for our options page:

/* Set the screen layout to one column
------------------------------------------------------------ */

add_filter( 'screen_layout_columns', 'ctsettings_settings_layout_columns', 10, 2 );
/**
 * ctsettings_settings_layout_columns function.
 *
 * This function sets the column layout to one for the CT Settings settings page.
 *
 * @param mixed $columns
 * @param mixed $screen
 * @return $columns
 *
 * @since 1.0.0
 *
 */
function ctsettings_settings_layout_columns( $columns, $screen ) {
	global $_ctsettings_settings_pagehook;
	if ( $screen == $_ctsettings_settings_pagehook ) {
		$columns[$_ctsettings_settings_pagehook] = 1;
	}
	return $columns;
}

Now let’s display our form and metaboxes, shall we? Copy and paste the following code into your file:

/* Build our theme options page
------------------------------------------------------------ */

/**
 * ctsettings_theme_options_page function.
 *
 * This function displays the content for the CT Settings settings page, builds the forms and outputs the metaboxes.
 *
 * @global $_ctsettings_settings_pagehook
 * @global $screen_layout_columns
 *
 * @since 1.0.0
 *
 */
function ctsettings_theme_options_page() {

	global $_ctsettings_settings_pagehook, $screen_layout_columns;
	$width = "width: 99%;";
	$hide2 = $hide3 = " display: none;";
	?>

	<div id="ctsettings" class="wrap genesis-metaboxes">
		<form method="post" action="options.php">

			<?php wp_nonce_field( 'closedpostboxes', 'closedpostboxesnonce', false ); ?>
			<?php wp_nonce_field( 'meta-box-order', 'meta-box-order-nonce', false ); ?>
			<?php settings_fields( CTSETTINGS_SETTINGS_FIELD ); ?>

			<?php screen_icon( 'options-general' ); ?>

			<h2>
				<?php _e( 'CT Settings - Theme Settings', 'genesis' ); ?>
				<input type="submit" class="button-primary genesis-h2-button" value="<?php _e( 'Save Settings', 'genesis' ) ?>" />
				<input type="submit" class="button-highlighted genesis-h2-button" name="<?php echo CTSETTINGS_SETTINGS_FIELD; ?>[reset]" value="<?php _e( 'Reset Settings', 'genesis' ); ?>" onclick="return genesis_confirm('<?php echo esc_js( __( 'Are you sure you want to reset?', 'genesis' ) ); ?>');" />
			</h2>

			<div class="metabox-holder">
				<div class="postbox-container" style="<?php echo $width; ?>">
					<?php do_meta_boxes( $_ctsettings_settings_pagehook, 'main', null ); ?>
				</div>
			</div>

		</form>
	</div>
	<script type="text/javascript">
		//<![CDATA[
		jQuery(document).ready( function($) {
			// close postboxes that should be closed
			$('.if-js-closed').removeClass('if-js-closed').addClass('closed');
			// postboxes setup
			postboxes.add_postbox_toggles('<?php echo $_ctsettings_settings_pagehook; ?>');
		});
		//]]>
	</script>

<?php }

Finally, we are able to actually display our form. We use the settings_fields function to output our security nonces and forms. We also add our submit/reset buttons to the top of the page. We use the do_meta_boxes function to fire and execute our metaboxes. Finally, we add some jQuery to make sure that our metaboxes toggle and move like they should. Now you can go into your Dashboard, refresh the page and check out your new child them options page! It should look something like this:

Now your users can select if they want to have any of these social sharing options displayed on their posts. Now we can create the functions that will conditionally add these social sharing options.

Adding in the Functionality to Your Child Theme’s functions.php File

For this tutorial, we are going to hook into the genesis_before_post_content action hook to add our social buttons. There are a wealth of other hooks that you can access, but we will use this one for this tutorial. Copy and paste the following code into your child theme’s functions.php file:

/* Add our social sharing buttons to our theme
------------------------------------------------------------ */

add_action( 'genesis_before_post_content', 'ctsettings_social_sharing_buttons' );
/**
 * ctsettings_social_sharing_buttons function.
 *
 * This function displays social sharing buttons based on the options selected by the user.
 *
 * @since 1.0.0
 *
 */
function ctsettings_social_sharing_buttons() {

	$perm = get_permalink();
	$title = get_the_title();

	if ( genesis_get_option( 'ctsettings_facebook_link', CTSETTINGS_SETTINGS_FIELD ) )
		echo '<div class="ctsettings-fb-like ctsettings-social-share">' . '<div id="fb-root"></div><script src="http://connect.facebook.net/en_US/all.js#xfbml=1"></script><fb:like href="'.$perm.'" send="false" layout="button_count" width="120" show_faces="false" action="like" font="lucida grande"></fb:like>' . '</div>';

	if ( genesis_get_option( 'ctsettings_twitter_link', CTSETTINGS_SETTINGS_FIELD ) )
		echo '<div class="ctsettings-tweet ctsettings-social-share">' . '<a href="http://twitter.com/share" class="twitter-share-button" data-count="horizontal" data-url="'.$perm.'" data-text="'.$title.'">Tweet</a><script type="text/javascript" src="http://platform.twitter.com/widgets.js"></script>' . '</div>';

	if ( genesis_get_option( 'ctsettings_google_link', CTSETTINGS_SETTINGS_FIELD ) )
		echo '<div class="ctsettings-google ctsettings-social-share">' . '<g:plusone size="medium" href="'.$perm.'"></g:plusone><script type="text/javascript">
			(function() {
   			var po = document.createElement("script"); po.type = "text/javascript"; po.async = true;
    		po.src = "https://apis.google.com/js/plusone.js";
    		var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(po, s);
  			})();
		</script>' . '</div>';

}

All this code is doing is checking to see if our option has been checked. If it has been checked, it display s the appropriate social sharing button. This bit of code also includes div classes so that you can these as needed.

And there you have it folks! You have no successfully and securely added child theme options to the Genesis Framework! Now go have some fun, tell all your friends and don’t forget to ask me questions if you have them.

Once again, here are the source files. Click on this link to download them now!

Setting Up the Function

I am going to be assuming you are using WordPress 3.0 or greater. If you are not, you need to update today! I’m not going to go through the data validation process (or input fields) for meta boxes, just the setup that displays the meta box. Here is what a typical setup for this will look like. Place the following code in your theme’s functions.php file:

add_action( 'add_meta_boxes', 'tgm_custom_meta_box' );
/**
 * tgm_custom_meta_box function.
 *
 * This function registers a metabox with the callback tgm_custom_meta_box_callback.
 * For reference: add_meta_box( $id, $title, $callback, $page, $context, $priority, $callback_args );
 *
 */
function tgm_custom_meta_box() {
    add_meta_box( 'meta_id', 'My Custom Meta Box', 'tgm_custom_meta_box_callback', 'post', 'normal', 'high' );
}

This is your basic meta box setup. Putting this into your functions.php file will display a meta box for the ‘post’ post type up under the Visual Editor with nothing in it (it may contain a warning, but that isn’t relevant for this tutorial). The limitation to this is that it only adds a meta box to the ‘post’ edit screen. Let’s change up the function tgm_custom_meta_box so that it will automatically add the meta box to each new post type we create, including the default post types of post and page.

/**
 * tgm_custom_meta_box function.
 *
 * This is an alternate version of tgm_custom_meta_box. This function adds a metabox to each registered post type in WordPress.
 *
 */
function tgm_custom_meta_box() {
	$post_types = get_post_types();
	foreach ( $post_types as $post_type ) {
    	add_meta_box( 'meta_id', 'My Custom Meta Box', 'tgm_custom_meta_box_callback', $post_type, 'normal', 'high' );
    }
}

The $post_types variable uses the get_post_types function to grab all of our post types. Then we simply use a foreach statement to apply this code to each meta box. Viola! This bit of code now automatically adds meta boxes to any new custom post types that you create. Pretty nifty, right?

Even More Uses

This is pretty cool, but what if you want to specify some post types for the meta boxes not to show up? We can easily do that too. Take a look at the following modification to our function:

/**
 * tgm_custom_meta_box function.
 *
 * This function adds a metabox only to custom post types that are set to be viewed as public.
 * This function also passes over the post types 'post' and 'page', meaning that the metabox will not appear on those respective edit screens.
 *
 */
function tgm_custom_meta_box() {
	$post_types = get_post_types( array( 'public' => true ) );
	foreach ( $post_types as $post_type ) {
		if ( $post_type == 'page' || $post_type =='post' )
			continue;
    	add_meta_box( 'meta_id', 'My Custom Meta Box', 'tgm_custom_meta_box_callback', $post_type, 'normal', 'high' );
    }
}

This is a more customized version of this function. First of all, our $post_types variable now has a condition. The $post_types variable will only accept post types that have the public argument set to true. There is a whole slew of arguments you could pass here. Just refer to the Codex on custom post types to learn about all the ones you could use.

Now check out the new “if” statement within the foreach construct. This “if” statement checks to see if the post type is either ‘page’ or ‘post’. If any of the “if” arguments are true, then we use continue statement to pass over that post type and go to the next post type (if there are any left in the array). You can add or take away from this as you would like to customize where your meta boxes are displayed.

And that just about wraps it up! I hope you’ve enjoyed the tutorial on how to automatically add meta boxes to custom post types. Be sure to tell all your friends!