To fix this issue, I’ve thrown together a quick widget that acts as a wrapper for Wordpress’ built-in widget, but lets you set a different link category for each language you have setup using WPML. I hope you find this useful.

To install, copy and paste this into your theme’s function.php file or insert code into a file in the plugins directory.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

add_action('widgets_init',  array('LinkTranslationWidget','register_widget'));
 
class LinkTranslationWidget extends WP_Widget
{	
 
	function LinkTranslationWidget() {
 
		/* Widget settings. */
		$widget_ops = array( 'classname' => 'LinkTranslationWidget', 'description' => __('This widget allows you to set different link categories to display based on a language setting.', $this->plugin_name) );
 
		/* Widget control settings. */
 
		/* Create the widget. */
		$this->WP_Widget( 'LinkTranslationWidget', __('WPML Links'), $widget_ops );
 
	}
 
	function register_widget()
	{
		register_widget('LinkTranslationWidget');
	}
 
	function widget( $args, $instance ) {
 
		global $sitepress;
 
		if(class_exists('WP_Widget_Links')) {
 
			$link_widget = new WP_Widget_Links();			
 
			if(isset($sitepress))
			{
 
				$lang = $sitepress->get_current_language();
				$instance['category'] = $instance[$lang.'_category'];					
				$link_widget->widget($args, $instance);
 
			}
 
 
 
		}
 
	}
 
	function update($new_instance, $old_instance) {
 
		$new_instance = (array) $new_instance;
		$instance = array( 'images' => 0, 'name' => 0, 'description' => 0, 'rating' => 0);
		foreach ( $instance as $field => $val ) {
			if ( isset($new_instance[$field]) )
				$instance[$field] = 1;
		}
 
		$langs = $this->GetLangs();
		foreach($langs as $lang=>$lang_id)
		{
			$instance[$lang.'_category'] = intval($new_instance[$lang.'_category']);
		}
 
		return $instance;
 
	}
 
	function form($instance) {
 
 
 
		$settings = $this->GetSettings();
		$langs = $this->GetLangs();
 
		$instance = wp_parse_args( (array) $instance, $settings );
 
		$link_cats = get_terms( 'link_category');
 
		foreach($langs as $lang=>$lang_id)
		{
			echo '<p><label for="'. $this->get_field_id($lang.'_category').'">'. __('Select Link Category') . ' (' .$lang.'): </label>';
			echo '<select id="'. $this->get_field_id($lang.'_category').'" name="'. $this->get_field_name($lang.'_category').'">';
			foreach ( $link_cats as $link_cat ) {
 
				echo '<option value="' . intval($link_cat->term_id) . '"'
				. ( $link_cat->term_id == $instance[$lang.'_category'] ? ' selected="selected"' : '' )
				. '>' . $link_cat->name . "</option>\n";
			}
			echo '</select></p>';
 
		}
		?>
		<p>
		<input class="checkbox" type="checkbox" <?php checked($instance['images'], true) ?> id="<?php echo $this->get_field_id('images'); ?>" name="<?php echo $this->get_field_name('images'); ?>" />
		<label for="<?php echo $this->get_field_id('images'); ?>"><?php _e('Show Link Image'); ?></label><br />
		<input class="checkbox" type="checkbox" <?php checked($instance['name'], true) ?> id="<?php echo $this->get_field_id('name'); ?>" name="<?php echo $this->get_field_name('name'); ?>" />
		<label for="<?php echo $this->get_field_id('name'); ?>"><?php _e('Show Link Name'); ?></label><br />
		<input class="checkbox" type="checkbox" <?php checked($instance['description'], true) ?> id="<?php echo $this->get_field_id('description'); ?>" name="<?php echo $this->get_field_name('description'); ?>" />
		<label for="<?php echo $this->get_field_id('description'); ?>"><?php _e('Show Link Description'); ?></label><br />
		<input class="checkbox" type="checkbox" <?php checked($instance['rating'], true) ?> id="<?php echo $this->get_field_id('rating'); ?>" name="<?php echo $this->get_field_name('rating'); ?>" />
		<label for="<?php echo $this->get_field_id('rating'); ?>"><?php _e('Show Link Rating'); ?></label>
		</p>
 
		<?php
 
	}
 
	function GetLangs()
	{
		global $sitepress_settings;
		$langs = $sitepress_settings['default_categories'];
		return $langs;
	}
 
	function GetSettings()
	{
		$settings = array();
 
		$settings['images'] = true;
		$settings['name'] = true;
		$settings['description'] = false;
		$settings['rating'] = false;
		$langs = $this->GetLangs();
		foreach($langs as $lang=>$lang_id)
		{
			$settings[$lang.'_category'] = '';
		}
		return $settings;
	}
 
}

If you are are using query_posts multiple times on a page, and are trying to paginate the second loop on the page, the following

$paged = (get_query_var('paged')) ? get_query_var('paged') : 1;

will always return 1, Unless you place wp_reset_query() below the previous loop.


rewind_posts();

if(have_posts())
{
?>
// Post template goes here.
}
wp_reset_query();
?>


Pagination should now work for the next loop.

While learning, I had a difficult time finding a straightforward template I could use as a base for my plug-ins. I wanted something that was clean and well-organized but also provided examples of more complex behaviours, such as: Internationalization, Widgets and Front and Back-End Ajax. I wanted to ensure my plug-in functionality was encapsulated inside a class structure so my functions and variables wouldn’t conflict with the Wordpress Core, or other plug-ins.

I’ve finally gotten around to writing this template plug-in, and I thought I would share it with the community to get your feedback and improvements, and hopefully save new developers some time. If you are interested in learning how to build a plug-in, and have a strong programming background, you can look through my sample code, read the comments and pretty much piece together how everything works. If you want a more thorough description of what is going on, read through this article.

You can download the plug-in from the Wordpress Plugin directory.

Getting Familiar With the Brolly Template Plug-in

1. Download the template plug-in.
2. Place the files in the plug-ins directory of your development installation of Wordpress.
3. Come up with a unique name for your plug-in, such as MyPlugin. Check the Wordpress Plug-in directory to ensure this name hasn’t been used.
4. Rename the plug-in folder from B2Template to your plug-in name (i.e. MyPlugin). Do not use spaces or special characters.
5. Rename the file B2Template.php to MyPlugin.php
6. Rename the file B2Template.class.php to MyPlugin.class.php
7. Rename the class inside MyPlugin.class.php from B2Template to MyPlugin
8. Rename the constructor function inside MyPlugin.class.php from B2Template() to MyPlugin()
9. Activate the plugin from the Wordpress Plugin Administration Panel
10. Add the Template widget to your sidebar from the Wordpress Appearance Administration Panel
11. View your site, and interact with the widget to observe it’s behaviour
12. From the Wordpress Administration page, click on Settings, and select MyPlugin.
13. Interact with the plugin from this page, to view its behaviour.

How to Write a Plugin Using the Brolly Template Plug-in

Note: Substitute B2Template in the instructions below, to whatever you named your plugin (i.e. MyPlugin).

There are two main files in the Brolly Wordpress Plug-in Template. The first, B2Template.php, is used to initialize the plugin and route various Wordpress actions and filters to class methods in the second file, B2Template.class.php. Keeping all our plug-in functions inside a class gives us greater flexibility to reuse the code we write for the plugin. It also prevents naming conflicts from occuring when multiple plug-ins use the same function or variable names.

Actions

After following the instructions above, the only modifications you should need to do to the B2Template.php file is adding or removing actions and filters. Wordpress uses actions to allow you to call plug-in functions after a specific event occurs. For example, you can register an action to call a plug-in function whenever a user deletes a post, publishes a page or whenever a comment is submitted. The Wordpress codex website provides a complete list of available actions. The B2Template plugin includes the following actions by default:

• init: Fires when the plugin loads
• admin_menu: Fires when wordpress is building the Administration menus on the back-end
• wp_print_scripts: Fires when Wordpress is building the tag for front-end pages
• wp_admin_print_scripts: Fires when Wordpress is building the tag for back-end pages
• widgets_init: Fires when Wordpress is loading widgets

You can easily add another action and route it to a function in the B2Template.class.php file by adding the following line to the B2Template.php file:

add_action('<ACTION NAME>', array($b2_plugin, '<CLASS FUNCTION NAME>'));

Where you replace with the Wordpress action you are adding, and with the function inside B2Template.class.php you want to be called.

Filters

Filters are similar to actions, except they let you modify data as it is being saved to the Wordpress database, or modify it before it is displayed to the end user. The Wordpress Codex provides a complete list of available filters. The B2Template provides the following filter by default:

• the_content: Passes the page or post content into the specified function as a string. You can then append, prepend or replace sections of this string using php, and then return the modified string at the end of the function. This is what will be displayed to the end user.

To add another filter and route it to a function in the B2Template.class.php file, add the following line to the B2Template.php file:

add_filter('<FILTER NAME>',array($b2_plugin, '<CLASS FUNCTION NAME>'));

Where you replace with the Wordpress filter you are adding, and with the function inside B2Template.class.php you want to be called. Here is an example of a filter function, that makes all post and page content uppercase.

function make_upper_case($content){
$filtered_content = strtoupper($content);
return $filtered_content;
}

Custom Actions

The Brolly Wordpress plug-in template is setup to allow you to create custom actions very easily. To understand the purpose and usage of custom actions, consider the following example.

You want to build a plugin that adds a link to the end of every post, that lets users rate a post between 1 and 5.

To do this, you would first create a Filter (see above), that appends an HTML drop-down box and submit button to the end of each post. When the user clicks the submit button, you need your plug-in to save this data to your database table. To do this, you can have your submit button POST to http://?B2Template_action=SaveTableData . Open the file B2Template.class.php, and scroll to the function ActionInit. This action gets called on every page load, so here you can check for the variable B2Template_action, and then call a class function based on whatever action you want perform. Here is an example of how you would use this function to save the submitted rating.

function ActionInit()
<pre>{
<pre style="padding-left: 30px; ">$action = $_REQUEST[$this->pf.'action'];
$this->SetLanguage();
switch ($action) {
case "SaveTableData":
$this->SaveTableData();
break;
}
}
function SaveTableData()
{
global $wpdb;
// Get POST data and perform SQL function to update database
}

Saving Data

If you only have a bit of data you need to collect from users, you can store this data in “Options”. Wordpress documents this well in the Creating Options Pages of the Wordpress Codex. There is an implementation of this in the GetConfigHTML function of B2Template.class.php.

If you are collecting more data, it may be handy to create a table for your plugin in the Wordpress Database. This process is documented in the Creating Tables with Plugins article of the Wordpress Codex. An implementation of this can be found in the Activate function of B2Template.class.php.

AJAX

Ajax isn’t too difficult to do within the Wordpress framework. The B2Template provides examples of how to do AJAX calls from the front-end and back-end. The first step is to make sure the ‘SACK’ javascript library is included. We do this by placing the following line in our ActionWpPrintScripts and ActionWpAdminPrintScripts functions in B2Template.class.php:

wp_enqueue_script( array( 'sack' ));

Using Wordpress’s wp_enqueue_script function allows you to load javascript libraries that come bundled with Wordpress, such as Scriptaculous, jQuery and SACK. It also ensures that multiple plugins don’t include the same library multiple times, improving page load time. The ActionWpPrintScripts function wraps this call inside an IF statement so the library is only loaded when the Template Widget is being used. It’s a good idea to do this so you avoid loading unnecessary javascript on pages that don’t use it. Likewise, the ActionAdminWpPrintScripts calls the function, IsPluginConfigPage, which checks to see if the user is looking at the plug-ins configuration page.

Next you should include the javascript files that performs the Ajax calls.

ActionWpPrintScripts:

wp_enqueue_script($this->pf.'js', $this->dir .'/js/js.php?url='.urlencode(get_bloginfo('url')));

ActionWpAdminPrintScripts:

wp_enqueue_script($this->pf.'admin_js', $this->dir.'/js/admin_js.php?url='.urlencode(get_bloginfo('url')));

These files can be found in the js/ folder. The JS files are saved as PHP, so that we can pass the blog’s url into the js files as query string variables. The following code demonstrates how to formulate an AJAX request that retrieves a result from the plug-in:

function B2Template_sample_data_save( content )
{
	var mysack = new sack(
		   "<?php $_REQUEST[ 'url']; ?>/wp-content/plugins/b2_template/b2_template.php" ); 
 
	  mysack.execute = 1;
	  mysack.method = 'POST';
	  mysack.setVar( "B2Template_action", "SaveTableData" );
	  mysack.setVar( "B2Template_sample_table_data", content );
	  mysack.encVar( "cookie", document.cookie, false );
	  mysack.onError = function() { alert('Error saving data.' )};
	  mysack.runAJAX();
 
	  return true;
 
}

In the first line, we specify the path to the plugin file. This is the file we are going to hit to return our result. The next line specifies that our Ajax call is going to return javascript that we want to be executed upon successful completion. The next line specifies that we are using the POST method. Next we set the variables we want to send to the server. Setting B2Template_action to SaveTableData means our Custom Action (see above) will handle the event. The next line states that we also want to POST the users COOKIE variables to the server as well (this isn’t totally necessary in this case). The next line specifies the javascript function that should run in case an error occurs. The final line executes the request.

NOTE: The class function you call using Ajax should echo out any javascript you want to run on the client side once the request is complete, and should then end with a call to  exit();.

For more information on Ajax in plugins view the article on Ajax in the Wordpress Codex.

Widgets

Making widgets with plugins is very easy. The function ActionWidgetsInit gets called in B2Template.class.php when Wordpress is registering sidebar widgets. Simply place the following line inside that function to register a widget:

register_sidebar_widget('Template Widget', array($this, 'TemplateWidget'));

This line creates a Widget called “Template Widget”, and instructs Wordpress to call the function TemplateWidget, inside this Class when it needs to get the Widget Content.

 function TemplateWidget( $args ) {
		extract($args);
 
		echo $before_widget.$before_title.__("Template Widget", $this->name). $after_title;
		echo __("Here is a list of interesting words: ", $this->name);
		echo '<div id="'.$this->pf.'widget">
				'.$this->GetWidgetData().'
				</div>';
		echo '<form>
					<br /><label><strong>'.__("Add your own", $this->name).'</strong></label> <input type="text" id="'.$this->pf.'sample_table_data" name="'.$this->pf.'sample_table_data" /><input type="button" onclick="'.$this->pf.'sample_data_save( document.getElementById(''.$this->pf.'sample_table_data').value )" value="'.__("Submit", $this->name).'"/>
				</form>';
		echo $after_widget;
	}

This function prints out the widget content. It receives the variable $args, which is an array containing the HTML code the user has specified they want to place before the Widget, before the Widget title, after the Widget title, and after the Widget. (This lets them wrap your widget inside a LI list item, or inside DIV tags, to make it jive with the theme they are using.)

Internationalization

I won’t go too deep into detail about internationalizing your plug-in. It is a great idea to design your plugin to support this, and it’s really no extra work if you take this approach from the beginning. Suffice it to say, that whenever you display language-specific text to a user or administrator, you should wrap it a simple function that attempts to find a translation for your text. Here is an example:

echo "This is a piece of text that can't be translated";

becomes

echo __("This is a piece of text that can be translated", $this->name);

In this example, we are simply echoing out a piece of text. The second parameter specifies the namespace of the translation which we’ve set to be the Class name of the function. We need namespaces for translations to ensure our translations don’t conflict with those made for other plugins or in the Wordpress core.

In order for translations to work, we need to call the function SetLanguage as soon as the plugin begins formulating output. This function, shown below, simply loads the translation textdomain.

function SetLanguage() {
load_plugin_textdomain( $this->name, WP_PLUGIN_DIR.'/'.$this->name.'/lang', $this->name.'/lang' );
}

Your plug-in is now ready to be translated, however, there are a few more steps to do before someone can actually translate your plug-in. For more information visit Wordpress’ documentation on Plugin Internationalization.

Conclusion

Those are the basics of the plug-in. If you have any questions, comments or other feedback feel free to comment. If you are interested in contributing to this plug-in please let us know and we can add you to the Wordpress SVN repository.

Like many of our other projects, the website is built upon the WordPress platform. We built a custom plugin for them to manage their upcoming movie listings. This plugin has some great features:

IMDB Integration

The Wordpress plugin allows the Mayfair Theatre to manage their upcoming movies and showtimes. Instead of forcing the administrator to enter in details for each movie that’s playing, we interfaced with a very neat movie database api, called The Movie Database, to allow them to import upcoming movie information, YouTube trailers and high quality artwork. This feature will saves huge amounts of time.

Twitter Integration

We set up the theatre with a twitter account, @mayfairtheatre, and used the Twitter API to automatically broadcast what movies are playing on a daily basis. We are encouraging users to follow the theatre’s Twitter account with a series of giveaways including: movie passes, free concession coupons and movie posters. We believe that keeping people informed of show times on a daily basis will greatly improve attendance.

Google Calendar

Another way we are keeping users up-to-date on the movie schedule is by integrating show times with Google Calendar using the Google API. This calendar stays synchronized with the online schedule and allows users to add the calendar to their computer and mobile devices.

By leveraging existing APIs we were able to build a lot of great functionality into the site, within a limited budget and short development cycle. It seems like every day we are finding new and exciting ways to expand WordPress to accommodate the diversity of our clients. Look for more exciting plugins and services coming soon!

Here at Brolly, we have just launched a new corporate website for Aurora Importing and Distributing, a medium sized Canadian food importing business, built entirely on the WordPress platform.

The Aurora Importing and Distributing website gives an indication of how powerful WordPress can be as a professional grade CMS. Using Wordpress’ plug-in functionality we were able to develop extensions to build a dynamic product locator which interfaces beautifully with the Google Maps API, an interactive product catalogue as well as offer the entire website in both French and English. We have also developed a plug-in that enables the company to synchronize their internal corporate data with the web server to ensure the site stays as current as possible. Employees at the company were easily trained on the extremely easy-to-use WordPress administration system and are able to publish frequent updates. Affordable professional hosting solutions provided by companies such as Media Temple allow you to host your website on reliable servers that will scale beautifully according to the demand on your web application.

WordPress has been in a constant state of development since 2003. Each iteration of the WordPress software is notoriously stable and upgrading is a painless process. It is easy to keep your website running with the latest offerings from the WordPress community allowing you to benefit from new security measures and added features. Many content management systems have poorly designed user interfaces, limited features and come with a hefty price tag. WordPress is gorgeous, robust and entirely free. Thanks to WordPress’ API, third party developers are able to easily build custom software solutions that integrate with WordPress seamlessly.

Visit Aurora Importing and Distributing’s new website and the Wordpress Showcase for some inspiration on what can be achieved using the WordPress platform. To get an idea of what the WordPress interface looks like, try starting your own blog on WordPress.com.

Adding in multiple sidebars is fairly straightforward and you can create as many as you need.

Locate your functions.php file in your theme and add the following code:

1
2
3
4
5
6
7
8
9
10

<?php
     if(function_exists('register_sidebar'))
          register_sidebar(array(
          'name' => 'Sidebar One', // The sidebar name to register
          'before_widget' => '<div class="widget">',
          'after_widget' => '</div>',
          'before_title' => '<h3>',
          'after_title' => '</h3>',
     ));
?>

You should be customizing and styling these values to match your WordPress theme.

To add additional sidebars simply repeat the code only changing the ‘name’ value. I registered three sidebars in the example below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?php
     // The first sidebar
     if(function_exists('register_sidebar'))
          register_sidebar(array(
          'name' => 'Sidebar One', // The sidebar name to register
          'before_widget' => '<div class="widget">',
          'after_widget' => '</div>',
          'before_title' => '<h3>',
          'after_title' => '</h3>',
     ));
     // The second sidebar
     if(function_exists('register_sidebar'))
          register_sidebar(array(
          'name' => 'Sidebar Two', // The sidebar name to register
          'before_widget' => '<div class="widget">',
          'after_widget' => '</div>',
          'before_title' => '<h3>',
          'after_title' => '</h3>',
     ));
     // The third sidebar
     if(function_exists('register_sidebar'))
          register_sidebar(array(
          'name' => 'Sidebar Three', // The sidebar name to register
          'before_widget' => '<div class="widget">',
          'after_widget' => '</div>',
          'before_title' => '<h3>',
          'after_title' => '</h3>',
     ));
?>

Finally you need to add each dynamic sidebar into your WordPress theme. Figure out where they should go and use the following code to activate each dynamic sidebar:

1
2
3
4
5
6

<?php
     if (!function_exists('dynamic_sidebar') || !dynamic_sidebar('Sidebar One')) : // Each sidebar name
?>
<?php
     endif;
?>

The entries from start to finish are linked below:

• Blogging 101: Anatomy of a Blog
• Blogging 101: Blogging Lingo
• Blogging 101: Before you Begin
• Blogging 101: Writing Tips
• Blogging 101: Networking Tips
• Blogging 101: Networking Tips (Part: 2)
• Blogging 101: Final Thoughts

• Research that you do from blogging on different topics will be well archived for later retrieval.
• Making your business more transparent, open and honest improves client relations.
• Future clients can assess your expertise by consulting the blog in which you have articulated your approach and complex ideas clearly and effectively.
• Feedback from readers will give you valuable information with which to improve your business approach.
• Participation in a community of professional peers will give you valuable business resources.

All this and more can result from a blog that works for you. So, to summarize, some of our most important recommendations for developing a successful business blog:

1. Cultivate a writing style that is characterized by an honest and authentic perspective that demonstrates your passion and expertise. Potential clients reading the blog will be drawn to authenticity above all else - they are not interested in reading promotional writing from the cold voice of a seemingly large business. They would like to support businesses run by people who love what they do and who are able to express their knowledge effectively.

2. Commit to regular posting to encourage loyal readers. Readers subscribe to blogs that are active with regular posts - the frequency of posting will reflect on the activity and vigour of the business itself.

3. Write posts that are on topic and of reasonable length (500 words is a good number to aim for).

4. Link abundantly to helpful resources for your readers and the posts of other blogs. If you make your site rich with resources in your industry, it will help to establish your business’ reputation and attract new clients and like-minded thinkers to help your business grow.

5. Respond with meaningful comments on the posts of other blogs, as well as those on your own blog. Build relationships in the blogosphere that will help to develop your business and create new opportunities. Make sure that your blog readers know you’re reading their comments and appreciating their feedback. If you keep the lines of communication open and active, potential clients will not hesitate to approach you.

6. Put yourself in the shoes of your readers and create posts that have value.

7. Use headlines that stand out and include relevant keywords.

8. Use embedded videos and images to enhance information and encourage readership. Make your blog an interesting place where you discuss your business and industry - if the atmosphere of the blog and its posts demonstrate expertise, enthusiasm and useful knowledge, you are more likely to attract a devoted readership.

9. Create a clear company blogging policy and/or comment moderation policy. Make it clear to your employee bloggers what is expected for the blog to ensure ongoing success.

10. Have fun! It shows.

Once blogging on a regular basis and beginning to build new relationships, it can be helpful to keep track of the progress of your blog. Statistics are easy to review for ongoing measurable information about the readers of your blog.

Recommended tools for monitoring statistics are:

• A Google Analytics account that will give you detailed information on who is visiting your site.
• A Feedburner account that will keep track of the number of subscribers.

You can also visit major blog search engines to find link citations to your site made by other bloggers. A few popular blog search engines are: Technorati, Feedster, Blogpulse and Bloglines.

In measuring your overall ROI and blog success, there are several metrics it can be helpful to review:

• Traffic (unique visits, page views and bounce rate)
• Length of time readers spend on your blog
• Total subscribers through RSS and Email
• Comments (total number and quality)
• Popularity on social bookmarking web sites
• Incoming links (where visitors are referred from)
• Total trackbacks
• Search engine ranking
• Blog ranking (on web sites such as Technorati)

Data from all of these sources will give you important information to help you improve your blog over the long term. Individual pages with a large amount of views could indicate that it is a topic readers are interested in or the quality of the post was especially good. Consider observing these trends in order to develop future posts for content that will be valuable to readers.

Negative or constructive feedback from the trackbacks of other bloggers may need to be responded to in a post. Especially positive trackbacks can be responded to by leaving a personal comment on their blog, fostering that new connection.