Edward Stafford» Code Mode

WordPress: Use Custom Fields To Add Keyword Metadata to Your Posts

Ed Stafford — Thu, 04 Feb 2010 11:00:10 +0000

Keywords for edwardstafford.com

One of the short-comings with using WordPress is that it does not provide an easy, built-in way to include metadata for your web page descriptions and keywords (and rightfully so). Why Not? The reason is simply that WordPress cannot read your mind. I know it’s hard to believe when you consider what you can do with wordpress, but it’s true. The issue with Description and Keyword page metadata is that, to be truely effective, it should be created to describe the content found on each individual page. It’s how search engines like google determine how to categorize and index each page. Now, there are some SEO “experts” who will argue that this information is not very relevant anymore, and I do agree with that for the most part, but there are still SEO benefits to including this metadata vs. not including it at all.

I’ve been giving this some thought lately and developed a couple ideas of how to add these features into a wordpress site without too much difficulty. A bulb went off in a moment clarity when I started to think about using the Custom Fields to store page specific metadata. I was even naive enough to think I was on to something new (should have known better) but as I started researching some ideas, I realized there were others already doing similar things. Oh well, a minor detail. I took my own approach to the idea anyway, if for no other reason than a learning exercise. Ultimately, this could be added as a premium feature to any custom theme using a couple hooks and some custom theme options magic.

Okay smarty-pants! So how do we include description and keyword metadata?

The solution isn’t difficult to implement and can be used to add page specific metadata inside the tag of any wordpress page. In this example, I’m going to show you a simple solution, but with some creativity and a little thought, you can expand this to provide a more robust solution for your own needs.

Part I: Defining a Custom “Keywords” Field

Custom Fields are a little used gem found in the Posts and Pages page of the WordPress dashboard / admin back end and available when you add a new post or page, or edit an existing post or page.

Create a new custom field

To create a new custom field to use for your page or post keywords, scroll down to the Custom Fields section below the main editor and click the “Enter new” link.

That action will activate the input fields for “Name” and “Value”.

In the Name field type the name identifier you’d like to use. This identifier/name will be used to reference the custom field name/value pair later so make it something relevant to avoid confusion. For this example, I am using “keywords“.

In the Value field, type the string of keywords or phrases that you want to use as the keyword metadata string for the page/post. For this example, I am using wordpress, seo, metadata, custom fields

Add New Custom Field Inputs

When you’re done, hit the “Add Custom Field” button.

If you have already created a “keywords” Custom Field for a previous page or post, you will have the option of selecting it in future pages and posts from the Name drop down menu.

Select from Custom Fields Menu

Select the Keywords item from the menu and then add the keywords or phrases for your new page to the Value field. When your done, make sure you hit the “Add Custom Field” button to confirm it.

That completes Part I. You now have a functional Custom Field assigned to your post/page.

Next up! Adding and understanding the code that generates the keyword metadata tag.

Part II: The Magic Code.

function set_keywords(){
global $post;
$keywords = get_post_meta($post->ID, ‘keywords’, true);
$default_keywords = “Your, selection, of, default, keywords”;
$metatag= “”;

if (empty($keywords)){
$keywords = $default_keywords;
}
if (is_home() || is_front_page()){
$keywords = $default_keywords;
}

$metatag=”\t”;
$metatag.= “ $metatag.= $keywords;
$metatag.= “\” />”;
$metatag.= “\n\n”;

echo $metatag;
}
add_action(‘wp_head’, ‘set_keywords’);

Adding this block of code to your Theme’s functions.php file will create and insert page specific Keyword Metadata into inside the tag of your pages and posts assuming you have completed Part I.

How the code works

function set_keywords(){

The first line declares our function and sets the name “set_keywords”.

global $post;
$keywords = get_post_meta($post->ID, ‘keywords’, true);
$default_keywords = “Your, selection, of, default, keywords”;
$metatag= “”;

These four lines set up the variables that will be used later in the function.

global $post allows the function to reference values stored in an array containing post information that was previously set by WordPress outside of the current function.

$keywords = get_post_meta($post->ID, ‘keywords’, true) is up next and sets our variable, $keywords to a string value equal to the “keywords” Custom Variable if it was set for the current page in Part I by calling the wordpress function get_post_meta().

get_post_meta() is passed three arguments.

The post ID ($post->ID)
a Custom Field Name reference (keywords)
a boolean value (true)

These three arguments tell get_post_meta() to grab the “keywords” Custom Field value for a specific page ($post_ID = a reference to the current page) and return a string result (true).

Note: If the Boolean argument were set to “false”, get_post_meta() would return an array object instead of a single string.

$default_keywords = “Your, selection, of, default, keywords” sets a set of default keywords to use when the $keywords variable is empty or not set, or when you just want to include a general set of keywords.

$metatag = “” rounds up the variables for the function and is used to build the metadata tag string that will be inserted into the page tag.

if (empty($keywords)){
$keywords = $default_keywords;
}

The next step in the code is a conditional statement. Here I use the common PHP empty() function passing the $keywords variable as an argument to check whether the $keywords variable contains a value. If the empty() function returns true it means that $keywords does not contain a usable value, or that is has not been set. If this condition is true, it will set the value of $keywords to that of $default_keywords.

If the Keywords Custom Field was set for the current page, then the get_post_meta() function should have set the $keywords variable to a usable value equal to the Keyword Custom Field value. The condition will return false and the variable retains it’s Custom Field value.

if (is_home() || is_front_page()){
$keywords = $default_keywords;
}

Next I have another conditional statement that uses WordPress functions to see if the current page is either the home page – is_home(), or the “blog” page – is_front_page() If the current page matches either of these pages, I want to assign the value of $default_keywords to the $keywords variable.

The reason I do this is because the content on these pages is more dynamic and has a tendency to change often, effecting keyword relevancy. So I want to provide a generic set of default keywords instead of page content specific keywords.

Note: It is possible, using more in-depth techniques not covered here, to also include the Keywords Custom Field for these pages and enable a set of more targeted keywords for them.

$metatag=”\t”;
$metatag.= “ $metatag.= $keywords;
$metatag.= “\” />”;
$metatag.= “\n\n”;

These lines are used to build the actual text string creating the metadata tag for our page’s tag. for example, if our page contained a keyword Custom Field with a value of ”keyword1, keyword2, keyword3″, the output for a blog post or single page would be:

echo $metatag;
}

Wrapping up the function we have echo $metatag followed by the closing bracket bringing our function to a close. echo $metatag simply writes the output of the $metatag variable to the source of your web page inserting the keyword meta tag in the page’s tag.

add_action(‘wp_head’, ‘set_keywords’);

And finally bringing this code bit to an end is add_action(‘wp_head’, ‘set_keywords’). The add_action() function is a wordpress function used to hook your custom function to a WordPress action. In this case we are hooking our function set_keywords to the wordpress action wp_head. This is the piece that actually inserts your meta tag into the page tag.

Note: It is up to the individual theme developers to include the wp_head action in their themes, so there is a chance that your theme will not have it. In that case, check the documentation for your theme to see what action hooks are available to you.

That pretty much wraps it up!

Umm, Aren’t you forgetting something?

By now you may be thinking, “Great, but what about the Description meta tag you mentioned?”.

You can use this same technique demonstrated here to create unique page descriptions with just a few minor code changes. Just replace keyword references with description references.

Do you have any suggestions to imporve on this? Find it helpful? Have some else to share? Leave a comment!

YouTube API Hack: Link Your Videos Directly to Your YouTube Channel

Ed Stafford — Fri, 07 Aug 2009 19:09:00 +0000

Wait! Your a Hacker?

First of all, my use of the word “Hack” is not the version popularized by the media. It is used here in the context of using a tool (YouTube API) to accomplish a task that was not originally part of the tool’s design. By using some creative thinking and little trial and error, I was able to accomplish a desired result, and overcome a limitation of the API.

Ready, Set, GO!!

While working on a recent project I came across a mildly irritating limitation of the YouTube API. The thing is, I wanted to display a list of recently added YouTube video thumbnails to a web site that link back to the videos in the YouTube users channel. Easy! right?

Not So Fast!

Here’s the thing. The channel feed returned by the API does include the link back to the YouTube Video, BUT it sends the visitor to the usual standard public YouTube page with the video embeded and NOT to the Channel of the YouTube member who uploaded it.

For most, this would be fine. But I wanted to be able to preserve a connection and identity between the web site and the YouTube Channel.

Unfortunately, the YouTube API does not provide a direct way to do this [link videos back directly to the YouTube Channel instead of the standard YouTube page]. So what’s a developer to do? … Come up with a hack, of course!! (even if is is a small one)..

First A Note:

This solution uses the Simplepie PHP Code Library to grab the Channel RSS feed

The Code:

require_once(‘php/simplepie.inc’);

$feed = new SimplePie(‘http://gdata.youtube.com/feeds/api/users/[user name]/uploads’);

$feed->handle_content_type();

$YT_PlayerPage = “http://www.youtube.com/user/[user name]#play/uploads/”;

$YT_VideoNumber = 0;
$ShowMax = 4;

foreach ($feed->get_items() as $item)
{

if ($enclosure = $item->get_enclosure())
{

$YT_VidID = substr(strstr($item->get_permalink(), ‘v=’), 2, 11);

echo ‘get_title() . ‘”> get_thumbnail() . ‘”/>’;

}
if($YT_VideoNumber == $ShowMax) break;
$YT_VideoNumber++;
}
?>

Tiptoe Through the Tulips (or walking through the code)

There you have it. A small block of PHP code and we have the result we’re looking for. Now let’s take a look at each line in the code.

require_once(‘php/simplepie.inc’);

This line does nothing more than call/include the Simplepie Library. The one thing you may need to change here is the location of the library. I stored it in a directory at the root of my web called “php”. So depending where you store your copy of the library, you may need to change this.

$feed = new SimplePie(‘http://gdata.youtube.com/feeds/api/users/[user name]/uploads’);

The next line creates a new feed and stores it as $feed. Pretty creative.. huh? Whats happening here is simplepie is grabing the rss feed for the YouTube Channel’s Uploaded videos.

An important note to make here is that the URI for the RSS passed to SimplePie is not the same as the RSS URI that you would use to subscribe to the channel’s RSS feed to use with your RSS reader. You will also need to replace [user name] in the URI with the YouTube user name for the channel you want to pull videos from.

The Standard RSS Subscription URI looks like this:
http://gdata.youtube.com/feeds/base/users/[user name]/uploads

While the URI used by the API to grab the RSS looks like this:
http://gdata.youtube.com/feeds/api/users/[user name]/uploads

Notice the difference indicated in bold text (“base” vs “api”). You will need to be sure you use “API” version of the URI. You can get this by copying the public RSS URI and simply changing “base” to “api”.

At the next line we have:

$feed->handle_content_type();

This just makes sure the content is being served out to the browser properly.

The next three lines contain three variables I’ve added: $YT_PlayerPage, $YT_VideoNumber and $ShowMax

$YT_PlayerPage = “http://www.youtube.com/user/[user name]#play/uploads/”;

This is the first part of the key to getting YouTube links to point directly to the Channel page. This variable holds the base Channel player URI and is used to construct a complete video link. The completed URI link also includes a counter reference and the unique 11 character video ID. To get the URI for the channel player page, visit the YouTube Channel you’re grabing the video feed from and click on a video link. The complete URI for that video will appear in the browser’s address bar. Simply copy that URI and eliminate everything following the backslash “/” after “uploads” (indicated in red)

http://www.youtube.com/user/[user name]#play/uploads/#/xxxxxxxxxxx

$YT_VideoNumber = 0;

The links on the YouTube Channel page contain a counter in the URI and increases by +1 with each link. This is the second part of the key in constructing the direct Channel links. This counter was a portion of the link that was removed in $YT_PlayerPage. I’m not completely clear on what the purpose of the counter is and in my experimenting with this, it did not seem to make a difference what the counter value was as long as the video ID followed it. But since it is the format that is used on YouTube’s Channel pages, I’ve figured it would be best to recreate the same thing here. Besides, we are going to use that value later in the code. I’ve set the initial value of the variable to 0 (zero) because the counter is zero based. (0, 1, 2 … )

$ShowMax = 4;

The next line contains the $ShowMax variable. This is used to set a limit to the number video links I wanted to display on the page. BUT, there is a trick you need to be aware of here. We are using the $YT_VideoNumber to get the counter number for the current video in the Loop (the loop will be described in the next section). But because $YT_VideoNumber is zero based, we need to compensate for that in the $ShowMax Variable and offset the limit by -1. In other words, to limit the display to 5 items, we need to set $ShowMax to 4 because we are including 0 as the first item (0 1 2 3 4) for a total of 5 items. Got it?… good!

foreach ($feed->get_items() as $item)
{

These lines start/open the Loop getting each item in the feed. This is where the code will “loop” through each item (video) in the feed and extract the information I wanted for each video.

if ($enclosure = $item->get_enclosure())
{

This line sets a conditional variable ($enclosure) to check if the current item in the loop contains enclosure data provided by MRSS (Multimedia RSS) that might be provided with the feed. YouTube feeds do support and provide MRSS enclosure data and we need to be able to pull it from the feed. The get_enclosure() method is part of the SimplePie Library and makes getting access to this data pretty easy.

$YT_VidID = substr(strstr($item->get_permalink(), ‘v=’), 2, 11);

This line is the final [and probably most important] part of the key to constructing the Channel video link. It’s also the most confusing part at first sight. I mentioned earlier that a video link is provided with the feed that will direct the viewer to a the standard public YouTube page for viewing. This link contains the video ID that we need. The bad news is that the API as far as I could see does not allow a direct or easy way to get the ID for each video [please correct me if I'm wrong here]. The good news is that the ID can be extracted from the link provided with the feed, and that’s exactly what this line does.

$item->get_permalink() returns the URI / video that would direct a visitor to the standard YouTube page. The URI is similar to:
http://www.youtube.com/watch?v=xxxxxxxxxxx

v=xxxxxxxxxxx of the URI contains the video ID and needs to be extracted.

substr(strstr($item->get_permalink(), ‘v=’), 2, 11) isolates and extracts the video ID and then stores the ID in the $YT_VidID variable.

Lets have a closer look.
We need to find the position in the URI string where the video ID starts and then extract it.

The video ID is passed in the URI as in query string paramater “v”. I used the PHP strstr() method to match and find the position of “v=”. This will create a new string eliminating everything in front “v=” so we are left with “v=xxxxxxxxxxx”.

If you look close, you’ll notice that strstr($item->get_permalink(), ‘v=’) and therefore the resulting string, is actually used as the string argument in the substr() method used to isolate the video ID.

The second argument, “2″ tells the substr method to offset the beginning of the string by two characters. This is to eliminate the “v” and “=” characters and moves the substring start position to the character after the “=” which is the first character of the Video ID.

The third argument, 11, tells the substr method to isolate the next eleven characters from the start position, leaving us with the full video ID “xxxxxxxxxxx”.

In experimenting and playing with this, I found that all YouTube video IDs are 11 characters long. I limited the substring to 11 instead of allowing it to extend to the end of the URI because, if for some reason additional string data was passed with the URI after the video ID, it would be included as part of the extracted string and the result would be an invalid ID.

After all that, I had the golden nugget of an isolated video ID which is now stored in the $YT_VidID variable. The hard part is DONE!! (really, it wasn’t that hard).

echo ‘get_title() . ‘”> get_thumbnail() . ‘”/>’;

The three key pieces needed to construct the direct Channel URIs are now available and the links can be put together. This line, still contained in our loop, constructs the link for each video item in the feed and outputs the HTML markup that will be included in the rendered page. To construct the link, join the three key pieces (the variables) like so:

$YT_PlayerPage . $YT_VideoNumber . “/” . $YT_VidID

$YT_PlayerPage = The base URI.
$YT_VideoNumber = The video counter
include a “/” character
$YT_VidID = The video ID

The output should look like:
http://www.youtube.com/user/[user name]#play/uploads/#/xxxxxxxxxxx

Include this string as the value of the href of an HTML tag.
‘
Next add a “title” attribute to the tag and set the value to $item->get_title().
“title=”‘ . $item->get_title() . ‘”>
This will create a hover text that shows the title of the video when the cursor hovers over the link.

Next, include the link content (text or image to act as the visible link). In my sample, I’ve used a thumbnail of each video.
get_thumbnail() . ‘”/>
Note that again I’m extracting the enclosure data included with MRSS as part of the RSS feed to get the thumbnail image for each video.

Finally add the closing tag to complete.

But wait … There’s more!!

}

The next line is nothing more than a closing bracket that closes and completes the conditional statement that checks for the enclosure data.

if($YT_VideoNumber == $ShowMax) break;

Remember the $ShowMax variable? This is where it comes into play. We are using the $YT_VideoNumber variable that was added to hold the counter for the current video and comparing it to the $ShowMax variable used to limit the number of videos the page will display. With each iteration of the loop, the code extracts the information for each video item and increments the counter by +1. The counter actually serves two purposes in the code. First, to be used in constructing the video URI and second, to control the point at which the loop is to be exited. Why?.. If our video feed has 100 items and we only want to display 5 of them, then it does not make any sense to continue stepping through the loop to read the remaining items. So after we get what we want, we exit the loop to save resources.

What’s happening here is this:
If the current $YT_VideoNumber variable value for the current iteration of the loop matches the value of the $ShowMax variable, then “break” (exit) out of the loop and we’re done.

$YT_VideoNumber++;

BUT, if the values of these variables does not match, then the next line increments the $YT_VideoNumber by +1 and continues to the next iteration of the loop.

}

And Finally, there is the closing bracket of the loop which also brings us to the end of the code block.

So that’s it. This code will render a set of YouTube video thumbnails in a web page that will link directly back to the video on the YouTube member’s channel page where ever it is included. But don’t stop there. Have a look at the other methods available in the YouTube API and SimplePie Library for additional information and data you can extract and use, add your own CSS and markup to the the output to change the layout, appearance, function … whatever you want.

I hope you found this useful. If you have any thoughts, improvements or comments to share, please post in the comments section here.

And if you do use this in your own projects, I’d really appreciate a comment in your code, a shoutout or link back to this post.

Happy coding!!!

Another example why Open Source is a good thing! (MySql + SharpDevelop)

Ed Stafford — Sat, 17 Nov 2007 03:48:16 +0000

I have some new additions and apps that I wanted to integrate into our company web (the company I work for) but this required upgrading from ASP.Net 1.1 to ASP.Net 2.0. Seems simple enough, right? I wish..!!

The site uses the MySql .NET Connector (a native ADO connector for .Net) available from MySQL AB. This worked flawlessly under the .Net 1.1 framework. I set up the 2.0 framework on our dev server and started testing the site localy to make sure all existing features and functions would still work after the switch. I am happy to announce that everything was working as expected (on the dev server). Now it was time to request the upgrade through the host. After receiving the confirmation that the request was completed, I open a browser and hit the company web. Warning Warning Error Error Error. Oh no!! What happened?

With the release of .NET 2.0, Microsoft included a new security model using a greater level of restriction. The host that is hosting our web makes use of these restriction levels and as it turns out, the .Net connector that we were using violated some .Net security and triggered a Security Exception.

Exception Details: System.Security.SecurityException: That assembly does not allow partially trusted callers.

I have to give Props to Microsoft for making the problem easy to identify. Looks like all I need to do is allow partially trusted calls from the MySql connector.

Here is where the Beauty of Open Source Software comes in.

MySql creates open source database software and tools and freely makes their source code available to anyone who wants it. That means I can take the source, make the changes I need and recompile the binaries again.

But wait! How do I access the source written in C# and recompile the binaries. Don’t I need something like Visual Studio from Microsoft. Thats like $1,024.99 (quoted from Amazon).

Sure you could drop a grand for VS Pro, or you could download SharpDevelop. SharpDevelop is the IDE equivelant to Visual Studio for C# development -and- did I mention it is FREE!! Yup that’s right Free Open Source Software (FOSS). I’ve been using SharpDevelop for a while now, and wouldn’t think of giving it up.

I fired up SharpDevelop, made the changes to the MySql .Net connector source necessary to allow it to operate within the restricted security settings of the host’s servers, and recompiled the binaries. As soon as I uploaded my newly compiled MySql Connector to the web server, I opened up my browser of choice and hit the company web site.

SUCCESS!!! All is good in the world again.

So how did using open source provide the advantage here?
1. if the MySql connector were closed, meaning I was not able to alter the code, I would have had to contact the company behind the software and try to get them to work with me towards a solution. The truth is, that is a long process and would probably require that I wait for them to release a new version of their closed proprietary product. With an inoperable web site, that was not an option.

2. Having access to FOSS (Free Open source Software) like SharpDevelop allowed me to do the same thing that other high priced software does, but for a lot less.

In the End, I was able to resolve a high priority issue quickly and at a low cost.

In all fairness, Microsoft does provide a -freely available- (for the beginner) version of Visual Studio IDEs know as Visual Studio Express. However, these are not Open Source and are very limited not only in features, but also in licensing which states what you are allowed to do with the projects you create.

Referencing ASP.NET CheckBox Controls using strings and casting

Ed Stafford — Tue, 22 May 2007 18:05:03 +0000

ASP.NET – I recently ported one of my older web ASP Application to a web ASP.NET Application which presented a few challenges along the way. One of these challenges was a need to manage a series of 30 check boxes within a form. This part of the application is used to manage user permissions, restricting what areas of the application individual users had access to.

The user permissions are stored in a database as a pipe (“|”) delimited string. when the page containing the form loads, the permission string is pulled from the database, and split into an array.

When loading a page, all the checkboxes that indicate a users permission need to be checked.

In good ol’e fashioned ASP, all the checkboxes in a form would be given the same “name” attribute, and a “value” attribute containing the permission string. When the page containing the form was loaded, a piece of client-side javascript would run and iterate through all the checkboxes. For each checkbox in the form, the script would then iterate through each permission array item and if the item matched the checkbox value attribute, the checkbox state would be set to “checked”.

ASP Form

Add Manage Delete Edit
set visibility

When the ASP page is submitted after altering user permissions (checking or unchecking boxes), server-side code gets the values of all the checked checkboxes using Request.Form(“Checkbox_name”) .value, converts it to a pipe (“|”) delimited string, and updates the database with the new delimited string.

When porting this to ASP.NET, we run into a problem when replacing the standard form checkboxes to ASP.NET CheckBox Controls. .Net CheckBox controls cannot have the same “name” attribute so we cannot access them as a group like we did in ASP. A workaround for this is to give each CheckBox Control an ID equal to the permission value.

ASP.NET Form

Now for the FUN.NET

Now instead of using a full block of client-side javascript and nested loops as we did in ASP, we can access the ASP.NET CheckBox Controls directly using a few lines of server-side code and Casting.

The key to this is the change from using a “value” attribute to contain the permission value to using the Control’s ID to contain the permission value. Because the permission values are stored and pulled from a database, and split into an array, each array item can also be used to reference the CheckBox Controls directly without having to loop through each control.

To set the checked state of the CheckBox controls, we loop through the permissions array and Cast the string as a CheckBox Control allowing us to access that specific control.

I am using a MySql database here:
First we need to get or data from the database. “access” is the DB table column that stores my permission string for each user.

MySqlConnection MyConString = new MySqlConnection(...your datababase connection string here...); MySqlCommand myCommand = new MySqlCommand("SELECT access FROM WHERE emp_ID = ", MyConString); MyConString.Open(); MySqlDataReader dr = myCommand.ExecuteReader();

Next we get the string value of “access” and split it into an array.

try{ dr.Read(); } catch(Exception ex){ however you want ot handle the exception here } char[] splitter = {'|'}; string[] arrPermissions = dr["access"].ToString().Split(splitter); setCheckboxes(arrPermissions);

setCheckboxes Method (this is where the magic happens)
This method takes the permissions array as a argument, iterates through the array, casting the string value of each item as a CheckBox, and sets the Checked state of all matching CheckBox Controls.

private void setCheckboxes(string[] arrPermissions) { foreach(string strPermission in arrPermissions){ ((CheckBox)this.CMSForm.FindControl(strPermission)).Checked = true; } }

The same technique can be applied to other .NET controls as well to change their attributes, styles, or whatever.
I could have just as easily changed the text of the controls using something like: ((CheckBox)this.CMSForm.FindControl(strPermission)).Text= “I am a CheckBox Control”;

PHP – Break the Web Shackles!

Ed Stafford — Thu, 10 May 2007 16:12:42 +0000

Over the last couple years or so, my development focus has been on the .NET Framework and C# so, I’m sad to say, it’s been a while since I’ve written any “real” PHP code. I think the main reason for this is that I have been developing more and more desktop applications and less web applications. When I was writing web apps, I’d say my efforts were split pretty much down the middle between PHP and ASP. Then .NET came along with C# and I was hooked. I was able to continue to develop web apps but also transition to desktop development while using the same tools. C# definitely had an advantage here. But alas.. I always kept the candle burning for PHP, my old friend, and occasionally checked in on it’s progress. I was excited about the release of PHP5 and it’s direction toward a true OO (object orientated) Programing approach. Finally, PHP would include:

“Real” Constructors

Added Destructors

Public, protected, and private properties and methods

Data Protection

Abstract classes

Static properties and methods

Exceptions, Custom Exceptions and Exception handling

This was a welcome change to PHP in my opinion. It’s true that with a little bit of work and an occasional hack, you could create classes and “sudo” objects in PHP4, BUT no matter how hard you try, it’s still not OOP. But even with all the improvements, PHP is still primarily used for web development leaving developers with the need to pick up other programing languages if they wish to venture into the desktop development arena. Right?

There is hope! Enter PHP-GTK. “What’s that” you ask?

Quote: PHP-GTK is an extension for the PHP programming language that implements language bindings for GTK+. It provides an object-oriented interface to GTK+ classes and functions and greatly simplifies writing client-side cross-platform GUI applications.

It is now possible to write functional windowed cross-platform applications for the desktop using PHP and GTK. ….HOORAH!! Originally released (ver. 0.0.1) in 2001, The project has progressed and come a long way. This is still a work in progress and there is a lot of work to do to make this comparable to other desktop development languages (C#, C++, JAVA etc.) but I am excited by the prospect. This puts PHP on the same playing field as the “big boys” and opens a whole new door of opportunities.

Today I finally decided to install the required pieces (GTK, PHP, a couple other packages) on my windows XP system and threw together a couple very small test apps. So far, so good!

Resources:
http://www.gnope.org/
http://gtk.php.net/
http://www.writingup.com/blog/phpgtk2
http://crisscott.com/category/php-gtk/

Creating Application Shortcuts for Click-Once Applications

Ed Stafford — Fri, 04 May 2007 02:57:48 +0000

While writing my latest C# .NET software application, the need came to be able to allow users to enable and disable an “auto-start” feature. Users wanted to control whether the app would start automatically when they start their workstation, or log into their accounts, or whether they had to start it manually. The challenge came out the fact that this was a very small application and was being created using VS C# Express and Click-Once deployment. My options were to either manipulate the registry run keys, or create a method to create/delete an application shortcut in the startup folder. I opted for the shortcut solution figuring it was probably the safest and easiest solution (VS express editions have limited access to registry manipulation, not to mention that any keys created through the use of the application would be orphaned after uninstall).

The first problem we have with the shortcut solution is that Click-Once deployments do not install (in the traditional sense) on the target system. The applications do not install in the Program Files directory and there is no control over setting or selecting a preferred location to install them. Instead, Click-Once applications are “installed” on a per-user basis to the active users profile > [...Documents and Settings\user_account\Local Settings\Apps\...\...] and when deployed in “off line” mode, Click_once also adds a sudo shortcut to the Start > All Programs menu. I say “Sudo” shortcut because it is not a traditional shortcut (.lnk) file, but instead an application reference file with an extension of .appref-ms

The directories below the “Apps” directory containing the executable files are not easily readable and appear to be dynamically generated by the Click-once deployment process [please correct me if I'm wrong]. This makes it impossible to include shortcuts in the project to access the executable without first knowing the absolute path to the executable after installation. If it is possible, I am not aware of how to go about doing it. Normally, I would have control over the installation path and directory structure so that I could include shortcut files with the project and copy/move them to the directories I need (programs folder – startup folder – etc) but we don’t have that ability with click_once deployments.

Another major problem is that the .NET framework does not provide a native class or method for creating shortcuts. Are you kidding me? With everything that the framework includes, I can’t easily create a (what should be) simple shortcut? PFFT!! Whatever… Help on the web was scarce and all the suggestions seemed to point to the same reference that showed how to create them using COM add-ins. I don’t want to go there.

I nearly pulled all my hair out trying to figure out how to overcome these problems and create a shortcut in the startup folder. Then it hit me..wait a minute..the click-once deployment already created an application reference (shortcut) in the All Programs folder. Why can’t I just use that? I was so caught up in “how to create the shortcut” that I almost overlooked the fact that it was already done.

My Solution (a simplified explaination):
This is Tray Icon Application that monitors an XML file and alerts users to updates and changes made to it.

Provide a MenuItem in the Tray Icon context menu to enable/disable the “auto-start” feature.

Include a method to copy the application reference created in the “All Programs” folder to the “Startup” folder – enable auto-start.

Include a method to delete the application reference (copy) from the “Startup” folder – disable auto-start.

Install using click-once deployment.

Test

How I did it [Code Samples]:

tsmiAutoStart_CheckChanged method:
This Method is called when the tsmiAutoStart menu item checked state changes

private void tsmiAutoStart_CheckedChanged(object sender, EventArgs e){ if (tsmiAutoStart.Checked) manage_startupAutoRun("copy"); else manage_startupAutoRun("delete"); }

manage_startupAutoRun method:
This method is triggered by the tsmiAutoStart_CheckedChanged method and creates or deletes an application reference shortcut in the users programs > startup menu enables the ability for users to control when/how the application runs (during startup, or manually)

“Action” parameter must be a string value of either “copy” or “delete”

private void manage_startupAutoRun(string action){ if (string.IsNullOrEmpty(startMenu_FolderName)) startMenu_FolderName = "Publisher Name"; //NOTE: startMenu_FolderName must be set to the value of Project Properties > Publish Tab > Options button > Publisher Name field string app_program_file = Environment.GetFolderPath(System.Environment.SpecialFolder.Programs) + "\" + startMenu_FolderName + "\" + Application.ProductName + ".appref-ms"; bool app_program_file_exists = System.IO.File.Exists(app_program_file); string startup_file = Environment.GetFolderPath(System.Environment.SpecialFolder.Startup) + "\" + Application.ProductName + ".appref-ms"; bool startup_file_exists = File.Exists(startup_file); startMenu_FolderName = string.Empty; switch (action) { case "delete": //remove application reference shortcut if (startup_file_exists) File.Delete(startup_file); break; case "copy": if ((app_program_file_exists) && (!startup_file_exists)) File.Copy(app_program_file, startup_file); //copy application reference shortcut break; default: throw new Exception("An invalid paramater [" + action + "] was passed to the manage_startupAutoRun method: accepts \"copy\" or \"delete\""); break; } }

autostart_enabled method:

Method is called during application load and returns a boolian value (true/false) based on the existance of an application reference shorcut located in the users programs > startup folder.

This method returns a boolean true/false value used to set the checked state of the MenuItem that calls the manage_startupAutoRun method. If the startup folder icon for the app exists, the MenuItem is set to checked and unchecked if it is not. This method is called only once during the application load.

private bool autostart_enabled(){ //check for shortcut in startup folder //if exists, set "checked" state for menu item //if not, set "unchecked" state for menu item. if (string.IsNullOrEmpty(startMenu_FolderName)) startMenu_FolderName = "Publisher Name"; //NOTE: startMenu_FolderName must be set to the value of Project Properties > Publish Tab > Options button > Publisher Name field string app_StartupFolderpath = Environment.GetFolderPath(System.Environment.SpecialFolder.Startup) + "\" + Application.ProductName + ".appref-ms"; startMenu_FolderName = string.Empty; return File.Exists(app_StartupFolderpath)? true : false; }

In the end, this process allows the user to control an “auto_start” feature by using the existing application reference file created in the “All Programs” menu and copying it to or deleting it from the Startup Menu programmatically from within the application.