Here is my Buddy List using the new “Grass” theme:

There are a lot of cool and very new things to try out in this beta. AOL needs your help. If you find any issues or have some suggestions, be sure to click on the “Beta Feedback” link and leave a comment. The IM window has a handy “Beta Feedback” link at the top as shown here:

Clicking on that link will open a browser window where you can leave your comments. Here is a screen shot of me leaving some feedback.

Remember, like saved away messages, you have to ask for the features you want in order to give them the attention you believe they deserve. Just make sure you ask for something you really want. Please comment early and often. The more details the better.

If you have not tried the first beta, be sure to try this one today.

Could it be the fastest AIM client yet?

Don’t let the minor version number fool you. These days, any version number higher than the previous one can signify an important update. AIM 6.9 is much improved over AIM 6.8, it is still FREE, and best of all, AOL has officially brought back the Running Man!

You can read more about this client on the AIM website and in some of my fellow teammate’s blog posts. There are also plenty of folks tweeting about it too.

I have been using this client throughout the betas and can confirm that all of my plugins work with AIM 6.9 as long as you update to their latest versions.

Try it today.

As a bonus tip, here is a quick way to switch your current buddy icon to the new Running Man (pictured above):

Enjoy.

01:58.754 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseTypingStatus'
   new value = No
01:58.755 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.privacy.discloseBuddyFeed'
   new value = No
01:58.764 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseIdleTime'
   new value = No
01:58.777 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.privacy.disclosePluginsToBuddyFeed'
   new value = No
01:58.777 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseWireless'
   new value = No
02:03.859 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseTypingStatus'
   new value = Yes
02:03.860 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.privacy.discloseBuddyFeed'
   new value = Yes
02:03.868 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseIdleTime'
   new value = Yes
02:03.869 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.Privacy.DiscloseWireless'
   new value = Yes
02:03.869 [gusblog  ] DAccEvents::OnPreferenceChange - 'aimcc.privacy.disclosePluginsToBuddyFeed'
   new value = Yes

You can get the latest version here.

Please note that activation of the CoreWitness plugin is now automatic. No registration is needed.

This is a free plugin for Open AIM developers.

I have known and worked with Gowri for a number of years now. Unfortunately, I just realized that I have never asked her where “madkat” came from. Be sure to check out her blog and let us know what ideas and issues you want answers on about Open AIM. Gowri is actually on the Open AIM team, so she has first-hand knowledge of all the current issues and questions that developers are stuck on. I look forward to her many great posts to come.

Lets all give Gowri a nice warm welcome to the blogging world.

P.S. Thanks for the kudos on my CoreWitness plugin — I enjoy developing it just as much as I enjoy using it.

How can I read these capabilities in the AIM SDK, you might ask? You can see what a user supports via the AccUserProp_Capabilities property and what the client asserts via the AccSessionProp_Capabilities property.

Here is a dump of the capabilities property for one of my screen names as seen by my CoreWitness plugin:

  AccUserProp_Capabilities = Array { ...GUIDs removed from trace here... } 
      {09461345-4C7F-11D1-8222-444553540000} = Direct IM
      {748F2420-6287-11D1-8222-444553540000} = Chat
      {09461343-4C7F-11D1-8222-444553540000} = File Transfer
      {67753137-6A38-6C77-4672-762D49755071} = UUID of a plugin: 'Gus Verdun's Core Test Plug-in (Dev)'
      {09461346-4C7F-11D1-8222-444553540000} = Buddy Icon
      {9FD3969B-84CB-45C1-B5DF-72DF5FAAB98E} = RX-Plugin

The AIM SDK returns an array of GUIDs in string form for those two properties. The CoreWitness plugin will automatically map the GUIDs to friendly names. When it encounters a GUID it does not recognize, it scans to see if the GUID matches that of any plugin you have installed. Yes, you can assert your plugin’s key as a capability if you want too. However, this is not required even thought your plugin’s key is reserved for you. I chose long ago to assert a different GUID as a capability for my RX-Plugin as you can see above. The capability is used to change the behavior of the IMpulse feature when both users have the RX-Plugin installed.

The AIM SDK always returns VB arrays in JavaScript so you must convert them to a JS array by using the toArray() method. Here is one way you can test to see if a buddy supports a particular capability:

// Test to see if buddy (IAccUser) has the RX-Plugin capability asserted
function HasRXPlugin(buddy)
{
    if ( SafeHasCapability(buddy, '{9FD3969B-84CB-45C1-B5DF-72DF5FAAB98E}') )
        alert('yes');
    else
        alert('no');
}
 
// cap must be in upper case.
function SafeHasCapability(user, cap)
{
    try {
        return  user.capabilities.toArray().join('').indexOf(cap) >= 0;
    } catch ( e ) {
        return false;
    }
}

The first function calls the more general function to test if the buddy has the capability asserted by my RX-Plugin.

You can use capabilities in your plugins for anything. They can be used to indicate that something is “on”, “selected”, etc. You can even have more than one—within reason. The AIM Vote ‘08 plugin uses capabilities to indicate your vote for McCain or Obama and then tallies up the number of buddies with either of those capabilities.

This release adds three new classes.

AccEx::CAccExPluginPreferences

This class wraps an AccEx::CAccExPreferences object to help you manage the reserved name space for preferences in a plugin. Open AIM Plugins can keep any number of preferences under the “aimcc.plugin.__GUID__.prefs.__PREF__” key specifier where __GUID__ is your plugin key and __PREF__ is any alphanumeric name for your preference.

The class is initialized with a pointer to the session and the plugin’s CLSID. It builds the base preference specifier for the plugin and gives you easy access to the preferences under it. The class also has methods to let you test if a given specifier is in the plugin’s name space and is of a particular preference. The GetPref() and SetPref() methods are identical to that of AccEx::CAccExPreferences with the only exception that you use the __PREF__ suffix rather than the full specifier.

AccEx::CAccExDAccEventSink

This class helps you implement your own DAccEvents handler. It differs from a the CAccEventSink supplied by the Open AIM SDK in a number of ways.

1. Supports ATL
2. Adds an OnPreEventMapFilter() function that you can use to filter out events
3. Adds an OnUnknownDispId() function that you can use to catch unhandled events
4. Wraps all calls to your handler functions in an exception handler
5. Adds an OnException() function that is called when an exception occurs
6. Event handlers are not virtual functions
7. Does not implement the IAccSession manager (See: AccEx::CAccExIAccSessionArray)

AccEx::CAccExIAccSessionArray

This class helps you keep track of up to 10 IAccSession objects. The purpose of this class is to encapsulate the management of these interfaces in an array along with their connection point cookie. You can add, remove, and find sessions. There are handy methods to get the first session, also known as the primary session, check if the array is empty, and check if a session is already registered.

You can download the latest release and get more information at the AccEx page.

In order to center a window, we need to know what monitor it’s in. Here is a function that returns the monitor for a given window:

function findMonitorForWindow(tWnd)
{
    // loop over all monitors until we find the one where
    // the top left corner of the target window is in
    for (var i=0; true; i++) 
    {
        var m = client.findWindow('_monitor'+i);
        if (m.exists)
        {
            if ( tWnd.x >= m.x && tWnd.x < (m.x + m.width) &&
                 tWnd.y >= m.y && tWnd.y < (m.y + m.height) ) 
                return m;
        }
        else
            break;
    }
    // default to first monitor
    return client.findWindow('_monitor0');
}

NOTE: ‘client’ above is the window.external.client object that has been assigned to a global variable.

Now that we can find the monitor for a given window, we can center the window any way we want in this monitor. Here is a function that centers the window over the region not occupied by a docked buddy list.

function BuddyListAwareCenterWindow(tWnd)
{
    // The standard center function:
    var center = function(o,w,n) { return (o + ((w-n)/2) ); }
 
    var tWndMonitor = findMonitorForWindow(tWnd);
    var blWnd = client.findWindow('_buddylist');
    var blWndMonitor = findMonitorForWindow(blWnd);
    var blWidth = 0, blOffset = 0;
 
    // are both windows in the same monitor?
    if (tWndMonitor.monitorIndex == blWndMonitor.monitorIndex)
    {
        // adjust centering width if bl is docked on either left or right
        if (blWnd.x == 0 || (blWndMonitor.width - blWnd.width) == blWnd.x )
            blWidth = blWnd.width;
        // adjust centering offset if docked on left.
        if (blWnd.x == 0)
            blOffset = blWnd.width;
    }
 
    tWnd.move( 
        center(tWndMonitor.x +  blOffset, tWndMonitor.width - blWidth, tWnd.width),
        center(tWndMonitor.y, tWndMonitor.height, tWnd.height) );
}

There are some edge cases like when a window is bigger than the space it’s centered on, but this solution should help you get started.

This release adds some handy helper functions ported over from some of my previous posts. One makes it easier to register plugin commands and the other makes it easy to register an active modeless window in your plugin so that dialog navigation keys are functional. These versions are public domain.

As a follow-on to my post on pushing data to the user’s Buddy Updates feed, I added a new function that can be called to push a plugin installed or updated item to the feed.

I am now including a Visual Studio 2005 build project.

See the AccEx page for more details.

First, I suggest you get about three or four screen names. Developing C++ plugins requires a lot of client re-starts which can get you log-in rate-limited very fast. Also don’t forget to take advantage of the edit and continue feature in Visual Studio while debugging since this will save you a login cycle.

Debugging a plugin is a little bit different than an entire application. I typically compile my plugin in Visual Studio. Then launch AIM using my IM control panel program. Incidentally, this app also lets me kill AIM completely which I need to do when I crash or want to force a restart. When I see the login window, I attach the debugger via the attach to process dialog (CTRL+ALT+P). Look for the aim6.exe process and attach to it. I then set my breakpoints and log in.

NB: There are two things you should note with the debugger. First is to make sure you are debugging native code and not script; very easy to miss. Second, is that your breakpoints will appear as inactive at this time since the plugin is not loaded yet. As long as you make sure you are debugging native code you should not have to worry too much about the breakpoints being disabled. They should light up once you are online.

AIM has its own crash handler that collects stack trace and other information to send along. Since I am developing my own plugin, it makes no sense to report these crashes to AOL. You can temporarily disable it by renaming the C:\Program Files\Common Files\AOL\AOLDiag\tbdiag.dll file to something else. Without it, all crashes get handled by Windows which lets you attach the debugger at the crash point.

With just these few tips you should be able to get started on debugging your own plugins easily.

I have a long list of posts to write this year and even more software ideas than ever. This year is already off to a great start.

Let me know if there are any topics you would like me to cover on Open AIM, Plugins, AIM Modules, AIM 6.x, etc.

I hope you find the content informative and interesting. Thank you for reading and trying out my plugins.

function SafePushTestFeed(session)
{
    try {
        manager = session.buddyFeedManager;
        myitem = manager.createBuddyFeed();
        myitem.feedTitle = 'Feed Title';
        myitem.feedLink = 'Feed Link';
        myitem.feedDescription = 'Feed Description'; 
        myitem.feedPublisher = 'Feed Publisher'; 
        myitem.itemTitle = 'Item Title';
        myitem.itemLink = 'Item Link';
        myitem.itemDescription = 'Item Description'; 
        myitem.itemGuid = 'Item Guid';
        myitem.itemCategory = 'Item Category';
        manager.push(myitem);
    }
    catch ( e ) 
    {
        // You can look this number up in the 
        // CoreWitness Symbol Lookup Dialog
        trace("Exception HRESULT=" + e.number);
    }
}

The buddyFeedManager is a property of the IAccSession interface. In C++ you access properties via the get_Property(prop, value) or get_XXX methods. However, from JavaScript you can access any property including the AccXXXProp_ ones by just using the property’s trailing name (everything after the AccXXXProp_ or get_). Property and method names are not case sensitive in JavaScript.

You can read more about the these interfaces by searching for the interface reference pages on IAccBuddyFeed and IAccBuddyFeedManager.

The first thing you should know before using this API is that you should observe some basic rules of netiquette:

• Don’t push anything without checking with the user first.
• Don’t persist any permission granted by the user unless you inform them of such persistence.
• Provide a place where the user can view and edit their permission to push items to their feed.

Please keep the above rules in mind as you write clients and plugins that push data to a user’s Buddy Updates feed.

Version 1.6.8 of the AIM SDK provides an interface that you can use to push just about anything to the user’s Buddy Updates Feed. This is the same API used by the AIM client to push all plugin installs.

To push an item to this feed you will need to do get the buddy feed manger (IAccBuddyFeedManager) from the session (IAccSession), create a buddy feed item (IAccBuddyFeed), set its properties, and finally push the item via the buddy feed manager. Here is a simple function that adds a test item to the feed:

HRESULT PushTestFeed(IAccSession *pSession)
{
    CComPtr<IAccBuddyFeedManager> spFeedManager;
    if ( SUCCEEDED( get_BuddyFeedManager(pSession, &spFeedManager) ) )
    {
        CComPtr<IAccBuddyFeed> spFeed;
        if ( SUCCEEDED( spFeedManager->CreateBuddyFeed( &spFeed ) ) )
        {
            put_FeedTitle(spFeed, CComBSTR(OLESTR("Feed Title")) );
            put_FeedLink(spFeed, CComBSTR(OLESTR("Feed Link")));
            put_FeedDescription(spFeed, CComBSTR(OLESTR("Feed Description")));
            put_FeedPublisher(spFeed, CComBSTR(OLESTR("Feed Publisher")));
            put_ItemTitle(spFeed, CComBSTR(OLESTR("Item Title")));
            put_ItemLink(spFeed, CComBSTR(OLESTR("Item Link"))); 
            put_ItemDescription(spFeed, CComBSTR(OLESTR("Item Descrtiption"))); 
            put_ItemGuid(spFeed, CComBSTR(OLESTR("Item GUID")));
            put_ItemCategory(spFeed, CComBSTR(OLESTR("Item Category")));
            AccTransId transId;
            return spFeedManager->Push(spFeed, &transId);
        }
    }
    return E_FAIL;
}

The result of pushing the above content to my feed is shown here:

...
<item>
    <title>Feed Title : Item Title</title>
    <link>Item Link</link>
    <description>Item Description</description>
    <author>gusblog</author>
    <aimId>gusblog</aimId>
    <pubDate>Wed, 28 Jan 2009 10:00:00 GMT</pubDate>
    <category>Item Category</category>
    <origFeedTitle>Feed Title</origFeedTitle>
    <origFeedLink>Feed Link</origFeedLink>
    <guid>Item Guid</guid>
</item>
...

AIM uses the feed’s link as the source for the favicon.ico when rendering it in the client and on the web. You must be in the online state before you can push an item. Pushing an item with an existing item GUID in the feed will replace the current content.

The buddy updates feed is a collection of all AIM Plugin installations, away and status message changes, third-party social media feeds, and more that your buddy has associated with his or her account.

The tool generates a URL for the Web AIM API that gets a user’s feed. This API is not bound by any authentication mechanism at this time so you can use it like any other RSS feed.

Give the AIM Buddy Feed URL Generator a try. The tool lets you enter the buddy’s name, feed format (rss,xml,json), optional category, max number of items, and level of detail. [NOTE: I have to admit that the feed category option did not work for me. I will investigate and add a comment when I have an answer.]

Here is a URL that returns the full RSS format of my feed.

The AIM SDK version 1.6.8 and the one used with AIM 6.8 both expose a Buddy Feed API that you can use to push additional content. I will cover how you can use this API to push any kind of data you want in a future post.

FAQ
Q: How can I control what goes in my buddy updates feed?
A: You can control what goes into your buddy feed at the AIM Settings Website. Just click on the “My Buddy Updates” tab.

For now, the only workaround is to un-dock the window before closing it:

// global aliases as described in a prior post
wnd = window.external.window;
client = window.external.client;
prefs = window.external.prefs;
 
function CloseDockedWindowWorkAround()
{
    // un-dock the window briefly.
    if (client.apiVersion == 1)
       client.docked = false;
    wnd.close();
}

This workaround will be needed in AIM 6.8 through AIM 6.9 Beta 2 (they all return an API version of 1).

I will get this issue fixed in the next AIM 6.9 beta since the plugin window is briefly shown in its undocked state before disappearing.

NOTE: This only applies to the dockable plugin window. All extra windows opened by the plugin can be closed without this workaround since those windows can never be docked.

The admin UI has improved extensively since the last version and I have been wanting to upgrade for some time since WordPress now support Google Gears. This should make posting a lot more interesting. From a reader’s perspective perhaps nothing has changed.

Let me know if you see any problems. Thanks.

One of the nicest aspects of AMO plugins is that you can install and uninstall them without having to sign off. This is fantastic from both a development and user perspective.

I recommend that you get an extra plugin key for developing plugins. Once you publish version 1 and set a finger print (optional) you will not be able to develop your plugin further with that key since only plugins with the registered fingerprint will be allowed to load. The solution to this is to get an extra key that you use for development purposes. Don’t forget to change to the deploy key before publishing.

Here are five tips to help get you started on developing your first plugin:

You can install a plugin by running the .amo file. I typically do “start plugin.amo” from the command line or make file. AIM registers itself as a handler for this file extension. You can install a plugin even while offline.

You should enable the debugging setting in IE for other apps. This helps you attach the JavaScript debugger during development and warns you about unhandled exceptions. With debugging enabled (i.e. not disabled), you can insert “debugger;” statements in your code to trigger the debugger. Go to the Internet Settings control panel and uncheck the highlighted option is to do this.

Create aliases for the window.external.* objects. This makes it easier to use these by assigning them to a variable. I put these at the top of my JavaScript file:

debug=1;
prefs = window.external.prefs;
client= window.external.client;
wnd = window.external.window;
plugin= client.pluginInfo;

Set the AMO_TRACE_ENABLE environment variable to “true” in order to use the window.external.client.trace(msg) function that sends output to the debugger. I do it via the Environment Variables dialog in the System Properties control panel (Windows+Break key, click on Advanced tab, then “Environment Variables” button.)

I also create a trace function that helps me leave trace message that are suppressed when the plugin is deployed. This is a good practice. Note that this code uses the global variables ‘debug’ and ‘client’ that I set up the previous tip. Remember to set debug=0 when you deploy your plugin.

function trace(m)
{
    if (debug)
        client.trace(m);
}

If your plugin fails to install for some reason, make sure your plugin.xml file is well-formed and that the minimum required attributes are there. Here are the minimum. The UUID must be your key with {}’s:

<?xml version="1.0" encoding="utf-8"?>
<plugin 
    schema     = "1"
    type       = "html"
    uuid       = "{00000000-0000-0000-0000-000000000000}"
    name      = "any name you want"
    .
    .
    .
</plugin>

Bonus Tip: See my posts tagged with “tips” for more.

NOTE: You must have my RX-Plugin installed in order to use this rule.

This rule lets you quickly send your buddy a link to look up the definition of a word. It sends an IM that says: “word” as defined by AIM Search and Wiktionary. All you have to do is type “/define word”, where “word” can be anything you want to look up, and send it.

I picked AIM Search because, after all, it’s all about AIM here. I also threw in a little bit of markup in the search URL that might just make the folks over at AIM Search do some searching of their own if this rule gets a lot of use. Trust me, that would be a nice problem to have.

Here is a screen shot of this rule in action:

This should make doing your homework and schooling your friends a little bit easier. Enjoy.

A complete introduction to AMOs is beyond the scope of this post. You can read more about the AIM Module Plugin API on the AIM Developer web site. I have written a few of these plugins under the AMO Factory brand.

In my previous post, I demonstrated how to read a preference via C++. Here is a sample that accomplishes the same in JavaScript.

// Make a shorter name for this. See the AMO API for docs on this class
client = window.external.client;
// Get the primary IAccSession object. 
// (primary is the first account that signs on.)
session = client.primarySession;
// Get the IAccPreferences object for this session
prefs = session.prefs;
 
// See the IAccPreferences API
function safeGetPref(spec, default)
{
    try {
        // method names of AIMcc objects are not case sensitive.
        return prefs.GetValue(spec);
    } catch (e) {}
    return default;
}
 
function canDisclosePluginsToBuddyFeed()
{
    return safeGetPref("aimcc.privacy.disclosePluginsToBuddyFeed", 
        false);
}
 
if (canDisclosePluginsToBuddyFeed()) 
{
    alert('preference is true');
}

I recommend that you use try/catch blocks around AIMcc method calls since they can return COM error results that throw exceptions in JavaScript. The safeGetPref() function takes care of this and returns the default value if AIMcc returns any error.

TIP: The e.number property in the catch block has the HRESULT as a negative number. You can find the symbolic name for this error via the Symbol Lookup dialog in my CoreWitness plugin. Just enter the number in the find box to do the reverse lookup.

It is up to clients to implement the actual data store behind these preferences by registering an object that implements either IAccPreferencesHook or IAccPreferencesHook2. You can find more information about these interfaces in technote 3 of the AIM SDK.

In this two-part series I will provide some sample code for reading preferences. This first post provides an ATL/C++ example and my next post will provide a JavaScript example.

In the process of making easy to use sample code, I will need to create some helper classes. These classes will be part of an evolving distribution called AccEx which I am hereby placing in the public domain. I will start by distributing these as source files only until I have more classes. AccEx distributions will be available here.

For this post, I created a helper class in AccEx called CAccExPreferences in order to make it easy to read and write preferences in C++. This class has overloaded methods to help you read a preference in various native formats like bool, int, float, etc. and one method to write a preference from a CComVariant.

So let’s use this thing. Like I said above, the IAccPreferences interface is implemented by AIMcc and associated with the IAccSession since they are (mostly) per-user preferences. Therefore, the only thing you need to initialize a CAccExPreferences object is an IAccSession pointer. The class will take care of acquiring the IAccPreferences interface for you. Here is a simple use-case that reads a real AIMcc preference.

// This sample source is public domain
#include <stdafx.h>
#include "AccExPreferences.h"
 
static WCHAR kDisclosePluginsToBuddyFeed[] = 
    OLESTR("aimcc.privacy.disclosePluginsToBuddyFeed");
 
HRESULT CanDisclosePluginsToBuddyFeed(IAccSession *pIAccSession)
{
    bool enabled;
    AccEx::CAccExPreferences prefs(pIAccSession);
 
    if ( SUCCEEDED( 
            prefs.GetPref(kDisclosePluginsToBuddyFeed, enabled) 
         ) && enabled )
    {
        // preference is enabled.
        return S_OK;
    }
    return S_FALSE;
}

Stay tuned for my next post where I will do the same using JavaScript.

For example, the other day I wanted to determine if the user has enabled the pushing of AIM Plugins to their buddy feed. I usually check in technote 10 on preferences in the AIM SDK technotes. However, you can also do this empirically in AIM with my CoreWitness plugin. All ‘aimcc.*’ preference changes will cause the OnPreferenceChanged event to fire on all listeners so you can simply make a change in the client to see what preference specifier is changing.

To make it easier, the latest version of my CoreWitness plugin lets you filter the messages being logged by pressing the * button in the title bar. To filter the log to just the OnPreferenceChanged event, open the filter dialog and proceed as follows. Click on the ‘clear all’ button and then start typing the word “preference” in the filter edit box until you see “OnPreferenceChange” appear in the list. Select this event and click OK. Here is a screen shot of this step:

After doing the above, I changed the ‘I have installed a new AIM Plugin’ check box in the privacy tab of AIM 6.9’s Settings and clicked apply. Here is a screen shot of my results:

As you can see the preference is called ‘aimcc.privacy.disclosePluginsToBuddyFeed’. Finding the preference specifier is only the beginning. I will cover how to read it in a future post.

NOTE: This will only work for aimcc.* preferences. So it is possible that you can make a change in the settings that does not get notified via OnPreferenceChange because it is internal to the client. Internal preferences are not available to pluigns at this time.

NOTE: You must have my RX-Plugin installed in order to use this rule.

This rule turns the sender’s screen name of every AIM Blast message into a link that you can click on to start a personal IM conversation.

Here is an example:

This should make your AIM Blast experience just a little bit better. Enjoy.

Blast groups appear as an automatically managed group in your buddy list. Once you have a blast group, just send an IM to the []-bracketed blast group buddy name.

You might have noticed that you need to reply with //1 or //2 when you receive an IM with the invitation to a blast group in order to accept or decline the invitation. It turns out there are many more commands that you can send to the blast group once you have joined.

Here is a list of additional commands you can send to blast group (NOTE: Most of these commands are handled by the host w/o being relayed to the blast group members):

//off

Stop receiving IMs. Use this when you are not interested in the current conversation. Don’t forget to send //on since this is in effect until then.

//on

Start receiving IMs again.

//invite name

Invite name to AIM Blast. An easy way to do this without having to go through the AIM Blast web site.

//history

Display last 10 IMs. This is an excellent way to check if you missed any recent blast messages.

//stats

Display stats

//soundon

Turn buddy sound on for the group

//soundoff

Turn buddy sound off for the group

//help

Get the list of // commands.

I found one more command that is not listed in the //help command and that is the //roll command to roll 2 six-sided dice; great for playing games and making random decisions via AIM Blast.

One last tip is that my Link Buddy plugin (also available from the AIM Gallery) has a link that gets you authenticated access to the AIM Blast web site so you don’t have to enter your password once you are signed-in to AIM.

I have released an update to my CoreWitness plugin for AIM. This version adds a few new features like the ability to pause and filter the messages being captured.

Here is a screen shot of the new filter dialog:

From this window you can select the messages you want to trace and click on apply, to activate your selection without closing the window, or OK to activate and close the window. You can save your selection as the default to be loaded at sign-on and when you click on load defaults button.

The contents of the event list will be updated as you type in the filter box to show just the events with the partial name. You can ctrl-click to select or de-select an event. The enable state of events not shown by the filter are preserved.

One last “feature” I added has more of a viral approach to getting the word out on this plugin (your help is appreciated). CoreWitness will push an activity to your buddy feed every time you install or upgrade this plugin. This will only be done if you have enabled the publishing of AIM Plugin installs in your privacy settings.

You can read more about this and download it on the Gus Verdun’s CoreWiteness Plugin-in web page.

Here you go:

use Digest::SHA;
use Win32::Clipboard;
 
$file = shift;
 
if ( -e $file && -f $file )
{
   $hash = uc( Digest::SHA->new(256)->addfile($file, 'b')->hexdigest );
   print "Plugin Fingerprint for '$file' (copied to clipboard): $hash\n";
   Win32::Clipboard()->Set( $hash );
}
else
{
   print "Usage: gushash [plugin_file_to_hash]\n";
}

Save this as gushash.pl in a location where your command shell can find it.

You will need Perl and the Digest-SHA package to use this script. The latter can be obtained through the ppm (Perl Package Manager) tool that is installed with Perl.

I’m always making little tools like this in Perl and Python to help me automate stuff.

This is here in case someone finds it useful…

I found an interesting post on Alley Insider about a Microsoft puzzle used to interest students in working at Microsoft. As a student of Python, I figured I was game.

I read the rules literally and wrote a Python application to produce all the permutations of the data. Here is the resulting code:

results = [];
def permutations(choices):
    for i in xrange(0,len(choices)):
        results.append( choices[i] );
        nextchoices = [word for word in choices if word != choices[i]];
        if len(nextchoices):
            permutations(nextchoices);
            results.pop();
        else:
            chars = [];
            for x in xrange(0,4):
                for y in xrange(0,len(results)):
                    chars.append(results[y][x]);
            print ''.join(chars);
            results.pop();
words = 'IOME HCRE REEC RNHA UATN'.split();
permutations(words);

It did not take me long to find out that one of those 120 permutations is “HURRICANEORTHEMENACE”.

Here is a capture from the AIM Gallery Web page:

This plugin is all aces in my book; Best part is that I did not even write it but I know the man that did.

Just look at the face of your candidate when he is winning or losing. Well done “Tommy Gunn”!

Click here to go to the AIM Gallery site where you can download this plugin.

Enjoy and be sure to vote on November 4th.

This new build has some interesting changes as mentioned on the AOL beta site release notes:

• Sign in as invisible is now an option in the sign in window — This check box is not sticky so you can’t check it and expect it to be checked the next time you sign in or out. This is a feature that was previously only available in my IM Tweaks plugin.
• The UI has been streamlined. We have removed some of the redundant menus and options — Less is more or less :). Be sure to send feedback on what you like or don’t like here.
• The buddy find feature is now similar to FireFox. Just press Ctrl+F from the Buddy List® window and begin typing the name of your buddy. You can close the find box to give yourself more room to show your Buddy List by clicking on the X button next to it.
• Search the web from your IM window. Just enter a query in the search box to open your browser and see the results. AIM Search is “powered by AOL search” and “enhanced by Google”.
• The AMO API continues to be improved in this version. Most of the changes are internal with a few API extensions. AIM 6.8 AMO plugins are also supported in AIM 6.9. I will cover some of these new API additions in a future post.
• One new feature not mentioned in the official release notes is a new option in the context menu of the IM compose box (Ctrl+D) that allows you to “paste as plain text”. This makes it ultra-easy to paste web content without messing up your fonts.

Here is a screen shot of AIM 6.9 beta 1 and beta 2 Buddy List windows with some of the highlighted changes. As you can see we moved the IM, Buddy List config, and Actions menu to the top under the main menu bar and gave them new icons. All plugin commands that were in the Actions menu are now in the menu with the gear icon.

You can download the latest AIM beta here. Let me know what you think.

I was absolutely positive I had seen this photo before but could not remember where until I visited the aim.com website and saw this on the page:

Have you seen this photo somewhere else? Post any you find in the comments (no spam please).

The DAccEvents Wizard helps you generate the code needed to handle Open AIM events in your own clients and plugins. It can generate code in C++ and JavaScript. The latter is useful for developing AMO plugins.

The Symbol Lookup window lets you quickly find the value of a particular constant. You can search by entering a partial name to see all the symbols containing that name. Or, you can do a reverse look up by entering a numeric value to see all the symbols with that value. You can click on any of the static text elements under the list box to copy the text to the clipboard. Clicking on the symbol’s name will copy an assignment statement to the clipboard.

You can find more information including screen shots and a download link here.

So far, this looks sharp. I like the way WordPress tells me that a plugin was updated and gives me the option to update it automattically. Very well done.