/*
 * Copyright 1999-2009 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Jeremy Friesner
 *		Fredrik Modéen
 */
 
 
#include "CommandActuators.h"
 
 
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
 
#include <String.h>
#include <Roster.h>
#include <Alert.h>
#include <Screen.h>
#include <Rect.h>
#include <View.h>
#include <Directory.h>
#include <Entry.h>
#include <List.h>
#include <Beep.h>
 
 
#include "ParseCommandLine.h"
#include "KeyInfos.h"
 
#define IS_KEY_DOWN(msg) ((msg->what == B_KEY_DOWN) \
	|| (msg->what == B_UNMAPPED_KEY_DOWN))
 
 
// factory function
CommandActuator*
CreateCommandActuator(const char* command)
{
	CommandActuator* act = NULL;
	int32 argc;
	char** argv = ParseArgvFromString(command, argc);
	if (command[0] == '*') {
		if (argc > 0) {
			char* c = argv[0] + 1;
			if (strcmp(c, "InsertString") == 0)
				act = new KeyStrokeSequenceCommandActuator(argc, argv);
			else if (strcmp(c, "MoveMouse") == 0)
				act = new MoveMouseByCommandActuator(argc, argv);
			else if (strcmp(c, "MoveMouseTo") == 0)
				act = new MoveMouseToCommandActuator(argc, argv);
			else if (strcmp(c, "MouseButton") == 0)
				act = new MouseButtonCommandActuator(argc, argv);
			else if (strcmp(c, "LaunchHandler") == 0)
				act = new MIMEHandlerCommandActuator(argc, argv);
			else if (strcmp(c, "Multi") == 0)
				act = new MultiCommandActuator(argc, argv);
			else if (strcmp(c, "MouseDown") == 0)
				act = new MouseDownCommandActuator(argc, argv);
			else if (strcmp(c, "MouseUp") == 0)
				act = new MouseUpCommandActuator(argc, argv);
			else if (strcmp(c, "SendMessage") == 0)
				act = new SendMessageCommandActuator(argc, argv);
			else
				act = new BeepCommandActuator(argc, argv);
		}
	} else
		act = new LaunchCommandActuator(argc, argv);
 
	FreeArgv(argv);
	return act;
}
 
 
//	#pragma mark - CommandActuator
 
 
CommandActuator::CommandActuator(int32 argc, char** argv)
{
}
 
 
CommandActuator::CommandActuator(BMessage* from)
	:
	BArchivable(from)
{
}
 
 
status_t
CommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = BArchivable::Archive(into, deep);
	return ret;
}
 
 
//	#pragma mark - LaunchCommandActuator
 
 
LaunchCommandActuator::LaunchCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv),
	fArgv(CloneArgv(argv)),
	fArgc(argc)
{
}
 
 
LaunchCommandActuator::LaunchCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
	BList argList;
	const char* temp;
	int idx = 0;
	while (from->FindString("largv", idx++, &temp) == B_OK) {
		if (temp) {
			char* copy = new char[strlen(temp) + 1];
			strcpy(copy, temp);
			argList.AddItem(copy);
		}
	}
 
	fArgc = argList.CountItems();
	fArgv = new char*[fArgc+ 1];
 
	for (int i = 0; i < fArgc; i++)
		fArgv[i] = (char*) argList.ItemAt(i);
 
	fArgv[fArgc] = NULL;// terminate the array
}
 
 
LaunchCommandActuator::~LaunchCommandActuator()
{
	FreeArgv(fArgv);
}
 
 
filter_result
LaunchCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage)) {
		// cause KeyEventAsync() to be called asynchronously
		*setAsyncData = (void*) true;
	}
	return B_SKIP_MESSAGE;
}
 
 
status_t
LaunchCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
 
	for (int i = 0; i < fArgc; i++)
		into->AddString("largv", fArgv[i]);
 
	return ret;
}
 
 
BArchivable*
LaunchCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "LaunchCommandActuator"))
		return new LaunchCommandActuator(from);
	else
		return NULL;
}
 
 
void
LaunchCommandActuator::KeyEventAsync(const BMessage* keyMessage,
	void* asyncData)
{
	if (be_roster == NULL)
		return;
 
	status_t result = B_OK;
	BString string;
	if (fArgc < 1)
		string << "You didn't specify a command for this hotkey.";
	else if ((result = LaunchCommand(fArgv, fArgc)) != B_OK) {
		string << "Can't launch " << fArgv[0];
		string << ", no such file exists.";
		string << " Please check your Shortcuts settings.";
	}
 
	if (fArgc < 1 || result != B_OK) {
		BAlert* alert = new BAlert("Shortcuts launcher error",
			string.String(), "OK");
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go(NULL);
	}
}
 
 
//	#pragma mark - MouseCommandActuator
 
 
MouseCommandActuator::MouseCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv),
	fWhichButtons(B_PRIMARY_MOUSE_BUTTON)
{
	if (argc > 1) {
		fWhichButtons = 0;
 
		for (int i = 1; i < argc; i++) {
			int buttonNumber = atoi(argv[i]);
 
			switch(buttonNumber) {
				case 1:
					fWhichButtons |= B_PRIMARY_MOUSE_BUTTON;
				break;
				case 2:
					fWhichButtons |= B_SECONDARY_MOUSE_BUTTON;
				break;
				case 3:
					fWhichButtons |= B_TERTIARY_MOUSE_BUTTON;
				break;
			}
		}
	}
}
 
 
MouseCommandActuator::MouseCommandActuator(BMessage* from)
	:
	CommandActuator(from),
	fWhichButtons(B_PRIMARY_MOUSE_BUTTON)
{
	from->FindInt32("buttons", &fWhichButtons);
}
 
 
MouseCommandActuator::~MouseCommandActuator()
{
}
 
 
status_t
MouseCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
	into->AddInt32("buttons", fWhichButtons);
	return ret;
}
 
 
int32
MouseCommandActuator::_GetWhichButtons() const
{
	return fWhichButtons;
}
 
 
void
MouseCommandActuator::_GenerateMouseButtonEvent(bool mouseDown,
	const BMessage* keyMessage, BList* outList, BMessage* mouseMessage)
{
	BMessage* fakeMouse = new BMessage(*mouseMessage);
	fakeMouse->what = mouseDown ? B_MOUSE_DOWN : B_MOUSE_UP;
 
	// Update the buttons to reflect which mouse buttons we are faking
	fakeMouse->RemoveName("buttons");
 
	if (mouseDown)
		fakeMouse->AddInt32("buttons", fWhichButtons);
 
	// Trey sez you gotta keep then "when"'s increasing if you want
	// click & drag to work!
	int64 when;
 
	const BMessage* lastMessage;
	if (outList->CountItems() > 0) {
		int32 last = outList->CountItems() - 1;
		lastMessage = (const BMessage*)outList->ItemAt(last);
	} else
		lastMessage = keyMessage;
 
	if (lastMessage->FindInt64("when", &when) == B_OK) {
		when++;
		fakeMouse->RemoveName("when");
		fakeMouse->AddInt64("when", when);
	}
 
	outList->AddItem(fakeMouse);
}
 
 
//	#pragma mark - MouseDownCommandActuator
 
 
MouseDownCommandActuator::MouseDownCommandActuator(int32 argc, char** argv)
	:
	MouseCommandActuator(argc, argv)
{
}
 
 
MouseDownCommandActuator::MouseDownCommandActuator(BMessage* from)
	:
	MouseCommandActuator(from)
{
}
 
 
MouseDownCommandActuator::~MouseDownCommandActuator()
{
}
 
 
filter_result
MouseDownCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage))
		_GenerateMouseButtonEvent(true, keyMessage, outList, mouseMessage);
 
	return B_DISPATCH_MESSAGE;
}
 
 
status_t
MouseDownCommandActuator::Archive(BMessage* into, bool deep) const
{
	return MouseCommandActuator::Archive(into, deep);
}
 
 
BArchivable*
MouseDownCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MouseDownCommandActuator"))
		return new MouseDownCommandActuator(from);
	else
		return NULL;
}
 
 
//	#pragma mark - MouseUpCommandActuator
 
 
MouseUpCommandActuator::MouseUpCommandActuator(int32 argc, char** argv)
	:
	MouseCommandActuator(argc, argv)
{
}
 
 
MouseUpCommandActuator::MouseUpCommandActuator(BMessage* from)
	:
	MouseCommandActuator(from)
{
}
 
 
MouseUpCommandActuator::~MouseUpCommandActuator()
{
}
 
 
filter_result
MouseUpCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage))
		_GenerateMouseButtonEvent(false, keyMessage, outList, mouseMessage);
 
	return B_DISPATCH_MESSAGE;
}
 
 
status_t
MouseUpCommandActuator::Archive(BMessage* into, bool deep) const
{
	return MouseCommandActuator::Archive(into, deep);
}
 
 
BArchivable*
MouseUpCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MouseUpCommandActuator"))
		return new MouseUpCommandActuator(from);
	else
		return NULL;
}
 
 
//	#pragma mark - MouseButtonCommandActuator
 
 
MouseButtonCommandActuator::MouseButtonCommandActuator(int32 argc, char** argv)
	:
	MouseCommandActuator(argc, argv),
	fKeyDown(false)
{
}
 
 
MouseButtonCommandActuator::MouseButtonCommandActuator(BMessage* from)
	:
	MouseCommandActuator(from),
	fKeyDown(false)
{
}
 
 
MouseButtonCommandActuator::~MouseButtonCommandActuator()
{
}
 
 
filter_result
MouseButtonCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage) != fKeyDown) {
		_GenerateMouseButtonEvent(IS_KEY_DOWN(keyMessage), keyMessage, outList,
			mouseMessage);
		fKeyDown = IS_KEY_DOWN(keyMessage);
 
		return B_DISPATCH_MESSAGE;
	} else {
		// This will handle key-repeats, which we don't want turned into lots
		// of B_MOUSE_DOWN messages.
		return B_SKIP_MESSAGE;
	}
}
 
 
status_t
MouseButtonCommandActuator::Archive(BMessage* into, bool deep) const
{
	return MouseCommandActuator::Archive(into, deep);
}
 
 
BArchivable*
MouseButtonCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MouseButtonCommandActuator"))
		return new MouseButtonCommandActuator(from);
	else
		return NULL;
}
 
 
//	#pragma mark - KeyStrokeSequenceCommandActuator
 
 
KeyStrokeSequenceCommandActuator::KeyStrokeSequenceCommandActuator(int32 argc,
	char** argv)
	:
	CommandActuator(argc, argv)
{
	for (int s = 1; s < argc; s++) {
		fSequence.Append(argv[s]);
		if (s < argc - 1)
			fSequence.Append(" ");
	}
 
	// Find any insert-unicode-here sequences and replace them with spaces...
	int32 nextStart;
	while ((nextStart = fSequence.FindFirst("$$")) >= 0) {
		int32 nextEnd = fSequence.FindFirst("$$", nextStart + 2);
		if (nextEnd >= 0) {
			uint32 customKey= 0;
			int32 unicodeVal= 0;
			uint32 customMods = 0;
			BString sub;
			fSequence.CopyInto(sub, nextStart + 2, nextEnd-(nextStart + 2));
			sub.ToLower();
 
			if ((sub.FindFirst('-') >= 0) || ((sub.Length() > 0)
				&& ((sub.String()[0] < '0') || (sub.String()[0] > '9')))) {
 
				const char* s = sub.String();
				while (*s == '-') s++;// go past any initial dashes
 
				bool lastWasDash = true;
				while (*s) {
					if (lastWasDash) {
						if (strncmp(s, "shift",5) == 0)
							customMods |=B_LEFT_SHIFT_KEY| B_SHIFT_KEY;
						else if (strncmp(s, "leftsh", 6) == 0)
							customMods |=B_LEFT_SHIFT_KEY| B_SHIFT_KEY;
						else if (strncmp(s, "rightsh",7) == 0)
							customMods |=B_RIGHT_SHIFT_KEY | B_SHIFT_KEY;
						else if (strncmp(s, "alt",3) == 0)
							customMods |=B_LEFT_COMMAND_KEY| B_COMMAND_KEY;
						else if (strncmp(s, "leftalt",7) == 0)
							customMods |=B_LEFT_COMMAND_KEY| B_COMMAND_KEY;
						else if (strncmp(s, "rightalt", 8) == 0)
							customMods |=B_RIGHT_COMMAND_KEY | B_COMMAND_KEY;
						else if (strncmp(s, "com",3) == 0)
							customMods |=B_LEFT_COMMAND_KEY| B_COMMAND_KEY;
						else if (strncmp(s, "leftcom",7) == 0)
							customMods |=B_LEFT_COMMAND_KEY| B_COMMAND_KEY;
						else if (strncmp(s, "rightcom", 8) == 0)
							customMods |=B_RIGHT_COMMAND_KEY | B_COMMAND_KEY;
						else if (strncmp(s, "con",3) == 0)
							customMods |=B_LEFT_CONTROL_KEY| B_CONTROL_KEY;
						else if (strncmp(s, "leftcon",7) == 0)
							customMods |=B_LEFT_CONTROL_KEY| B_CONTROL_KEY;
						else if (strncmp(s, "rightcon", 8) == 0)
							customMods |=B_RIGHT_CONTROL_KEY | B_CONTROL_KEY;
						else if (strncmp(s, "win",3) == 0)
							customMods |=B_LEFT_OPTION_KEY | B_OPTION_KEY;
						else if (strncmp(s, "leftwin",7) == 0)
							customMods |=B_LEFT_OPTION_KEY | B_OPTION_KEY;
						else if (strncmp(s, "rightwin", 8) == 0)
							customMods |=B_RIGHT_OPTION_KEY| B_OPTION_KEY;
						else if (strncmp(s, "opt",3) == 0)
							customMods |=B_LEFT_OPTION_KEY | B_OPTION_KEY;
						else if (strncmp(s, "leftopt",7) == 0)
							customMods |=B_LEFT_OPTION_KEY | B_OPTION_KEY;
						else if (strncmp(s, "rightopt", 8) == 0)
							customMods |=B_RIGHT_OPTION_KEY| B_OPTION_KEY;
						else if (strncmp(s, "menu", 4) == 0)
							customMods |=B_MENU_KEY;
						else if (strncmp(s, "caps", 4) == 0)
							customMods |=B_CAPS_LOCK;
						else if (strncmp(s, "scroll", 6) == 0)
							customMods |=B_SCROLL_LOCK;
						else if (strncmp(s, "num",3) == 0)
							customMods |=B_NUM_LOCK;
						else if (customKey == 0) {
							BString arg = s;
							int32 dashIdx = arg.FindFirst('-');
 
							if (dashIdx >= 0)
								arg.Truncate(dashIdx);
 
							uint32 key = (uint32)FindKeyCode(arg.String());
 
							if (key > 0) {
								customKey = key;
								const char* u = GetKeyUTF8(key);
 
								//Parse the UTF8 back into an int32
								switch(strlen(u)) {
									case 1:
										unicodeVal = ((uint32)(u[0]&0x7F));
										break;
									case 2:
										unicodeVal = ((uint32)(u[1]&0x3F)) |
											(((uint32)(u[0]&0x1F)) << 6);
										break;
									case 3:
										unicodeVal = ((uint32)(u[2]&0x3F)) |
											(((uint32)(u[1]&0x3F)) << 6) |
											(((uint32)(u[0]&0x0F)) << 12);
										break;
									default: unicodeVal = 0;
										break;
								}
							}
						}
						lastWasDash = false;
					} else
						lastWasDash = (*s == '-');
 
					s++;
				}
 
				// If we have a letter, try to make it the correct case
				if ((unicodeVal >= 'A') && (unicodeVal <= 'Z')) {
					if ((customMods & B_SHIFT_KEY) == 0)
						unicodeVal += 'a'-'A';
				} else if ((unicodeVal >= 'a') && (unicodeVal <= 'z')) {
					if ((customMods & B_SHIFT_KEY) != 0)
						unicodeVal -= 'a'-'A';
				}
			} else {
				unicodeVal = strtol(&(fSequence.String())[nextStart + 2],
					NULL, 0);
				customMods = (uint32) -1;
			}
 
			if (unicodeVal == 0)
				unicodeVal = ' ';
 
			BString newString = fSequence;
			newString.Truncate(nextStart);
			fOverrides.AddItem((void*)(addr_t)unicodeVal);
			fOverrideOffsets.AddItem((void*)(addr_t)newString.Length());
			fOverrideModifiers.AddItem((void*)(addr_t)customMods);
			fOverrideKeyCodes.AddItem((void*)(addr_t)customKey);
			newString.Append((unicodeVal > 0
				&& unicodeVal < 127) ? (char)unicodeVal : ' ', 1);
			newString.Append(&fSequence.String()[nextEnd + 2]);
			fSequence = newString;
		} else
			break;
	}
 
	_GenerateKeyCodes();
}
 
 
KeyStrokeSequenceCommandActuator::KeyStrokeSequenceCommandActuator(
	BMessage* from)
	:
	CommandActuator(from)
{
	const char* sequence;
	if (from->FindString("sequence", 0, &sequence) == B_OK)
		fSequence = sequence;
 
	int32 temp;
	for (int32 i = 0; from->FindInt32("ooffsets", i, &temp) == B_OK; i++) {
		fOverrideOffsets.AddItem((void*)(addr_t)temp);
 
		if (from->FindInt32("overrides", i, &temp) != B_OK)
			temp = ' ';
 
		fOverrides.AddItem((void*)(addr_t)temp);
 
		if (from->FindInt32("omods", i, &temp) != B_OK)
			temp = -1;
 
		fOverrideModifiers.AddItem((void*)(addr_t)temp);
 
		if (from->FindInt32("okeys", i, &temp) != B_OK)
			temp = 0;
 
		fOverrideKeyCodes.AddItem((void*)(addr_t)temp);
	}
 
	_GenerateKeyCodes();
}
 
 
KeyStrokeSequenceCommandActuator::~KeyStrokeSequenceCommandActuator()
{
	delete[] fKeyCodes;
	delete[] fModCodes;
	delete[] fStates;
}
 
 
void
KeyStrokeSequenceCommandActuator::_GenerateKeyCodes()
{
	int slen = fSequence.Length();
	fKeyCodes = new int32[slen];
	fModCodes = new int32[slen];
	fStates = new uint8[slen * 16];
 
	memset(fStates, 0, slen * 16);
 
	key_map* map;
	char* keys;
	get_key_map(&map, &keys);
	for (int i = 0; i < slen; i++) {
		uint32 overrideKey = 0;
		uint32 overrideMods = (uint32)-1;
		for (int32 j = fOverrideOffsets.CountItems()-1; j >= 0; j--) {
			if ((int32)(addr_t)fOverrideOffsets.ItemAt(j) == i) {
				overrideKey= (uint32)(addr_t) fOverrideKeyCodes.ItemAt(j);
				overrideMods = (uint32)(addr_t) fOverrideModifiers.ItemAt(j);
				break;
			}
		}
 
		uint8* states = &fStates[i * 16];
		int32& modCode = fModCodes[i];
		if (overrideKey == 0) {
			// Gotta do reverse-lookups to find out the raw keycodes for a
			// given character. Expensive--there oughtta be a better way to do
			// this.
			char next = fSequence.ByteAt(i);
			int32 key = _LookupKeyCode(map, keys, map->normal_map, next,
				states, modCode, 0);
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->shift_map, next, states,
					modCode, B_LEFT_SHIFT_KEY | B_SHIFT_KEY);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->caps_map, next, states,
					modCode, B_CAPS_LOCK);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->caps_shift_map, next,
					states, modCode,
					B_LEFT_SHIFT_KEY | B_SHIFT_KEY | B_CAPS_LOCK);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->option_map, next, states,
					modCode, B_LEFT_OPTION_KEY | B_OPTION_KEY);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->option_shift_map, next,
					states, modCode, B_LEFT_OPTION_KEY | B_OPTION_KEY
						| B_LEFT_SHIFT_KEY | B_SHIFT_KEY);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->option_caps_map, next,
					states, modCode,
					B_LEFT_OPTION_KEY | B_OPTION_KEY | B_CAPS_LOCK);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->option_caps_shift_map,
					next, states, modCode, B_LEFT_OPTION_KEY | B_OPTION_KEY
						| B_CAPS_LOCK | B_LEFT_SHIFT_KEY | B_SHIFT_KEY);
			}
 
			if (key < 0) {
				key = _LookupKeyCode(map, keys, map->control_map, next, states,
					modCode, B_CONTROL_KEY);
			}
 
			fKeyCodes[i] = key >= 0 ? key : 0;
		}
 
		if (overrideMods != (uint32)-1) {
			modCode = (int32)overrideMods;
 
			// Clear any bits that might have been set by the lookups...
			_SetStateBit(states, map->caps_key, false);
			_SetStateBit(states, map->scroll_key, false);
			_SetStateBit(states, map->num_key, false);
			_SetStateBit(states, map->menu_key, false);
			_SetStateBit(states, map->left_shift_key, false);
			_SetStateBit(states, map->right_shift_key, false);
			_SetStateBit(states, map->left_command_key, false);
			_SetStateBit(states, map->right_command_key, false);
			_SetStateBit(states, map->left_control_key, false);
			_SetStateBit(states, map->right_control_key, false);
			_SetStateBit(states, map->left_option_key, false);
			_SetStateBit(states, map->right_option_key, false);
 
			// And then set any bits that were specified in our override.
			if (modCode & B_CAPS_LOCK)
				_SetStateBit(states, map->caps_key);
 
			if (modCode & B_SCROLL_LOCK)
				_SetStateBit(states, map->scroll_key);
 
			if (modCode & B_NUM_LOCK)
				_SetStateBit(states, map->num_key);
 
			if (modCode & B_MENU_KEY)
				_SetStateBit(states, map->menu_key);
 
			if (modCode & B_LEFT_SHIFT_KEY)
				_SetStateBit(states, map->left_shift_key);
 
			if (modCode & B_RIGHT_SHIFT_KEY)
				_SetStateBit(states, map->right_shift_key);
 
			if (modCode & B_LEFT_COMMAND_KEY)
				_SetStateBit(states, map->left_command_key);
 
			if (modCode & B_RIGHT_COMMAND_KEY)
				_SetStateBit(states, map->right_command_key);
 
			if (modCode & B_LEFT_CONTROL_KEY)
				_SetStateBit(states, map->left_control_key);
 
			if (modCode & B_RIGHT_CONTROL_KEY)
				_SetStateBit(states, map->right_control_key);
 
			if (modCode & B_LEFT_OPTION_KEY)
				_SetStateBit(states, map->left_option_key);
 
			if (modCode & B_RIGHT_OPTION_KEY)
				_SetStateBit(states, map->right_option_key);
		}
 
		if (overrideKey > 0) {
			if (overrideKey > 127) {
				// invalid value?
				overrideKey = 0;
			}
 
			fKeyCodes[i] = overrideKey;
			_SetStateBit(states, overrideKey);
		}
	}
 
	free(keys);
	free(map);
}
 
 
int32
KeyStrokeSequenceCommandActuator::_LookupKeyCode(key_map* map, char* keys,
	int32 offsets[128], char c, uint8* setStates, int32& setModifier,
	int32 setTo) const
{
	for (int i = 0; i < 128; i++) {
		if (keys[offsets[i]+ 1] == c) {
			_SetStateBit(setStates, i);
 
			if (setTo & B_SHIFT_KEY)
				_SetStateBit(setStates, map->left_shift_key);
 
			if (setTo & B_OPTION_KEY)
				_SetStateBit(setStates, map->left_option_key);
 
			if (setTo & B_CONTROL_KEY)
				_SetStateBit(setStates, map->left_control_key);
 
			if (setTo & B_CAPS_LOCK)
				_SetStateBit(setStates, map->caps_key);
 
			setModifier = setTo;
 
			return i;
		}
	}
 
	return -1;
}
 
 
void
KeyStrokeSequenceCommandActuator::_SetStateBit(uint8* setStates, uint32 key,
	bool on) const
{
	if (on)
		setStates[key / 8] |= (0x80 >> (key % 8));
	else
		setStates[key / 8] &= ~(0x80 >> (key % 8));
}
 
 
status_t
KeyStrokeSequenceCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t result = CommandActuator::Archive(into, deep);
	if (result != B_OK)
		return result;
 
	into->AddString("sequence", fSequence.String());
	int32 numOverrides = fOverrideOffsets.CountItems();
 
	status_t overridesResult = B_OK;
	for (int32 i = 0; i < numOverrides; i++) {
		result = into->AddInt32("ooffsets",
			(int32)(addr_t)fOverrideOffsets.ItemAt(i));
		if (result != B_OK)
			overridesResult = B_ERROR;
 
		result = into->AddInt32("overrides",
			(int32)(addr_t)fOverrides.ItemAt(i));
		if (result != B_OK)
			overridesResult = B_ERROR;
 
		result = into->AddInt32("omods",
			(int32)(addr_t)fOverrideModifiers.ItemAt(i));
		if (result != B_OK)
			overridesResult = B_ERROR;
 
		result = into->AddInt32("okeys",
			(int32)(addr_t)fOverrideKeyCodes.ItemAt(i));
	}
 
	return overridesResult == B_ERROR ? B_ERROR : result;
}
 
 
filter_result
KeyStrokeSequenceCommandActuator::KeyEvent(const BMessage* keyMessage,
	BList* outList, void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage)) {
		BMessage temp(*keyMessage);
		int numChars = fSequence.Length();
		for (int i = 0; i < numChars; i++) {
			char nextChar = fSequence.ByteAt(i);
 
			temp.RemoveName("modifiers");
			temp.AddInt32("modifiers", fModCodes[i]);
			temp.RemoveName("key");
			temp.AddInt32("key", fKeyCodes[i]);
			temp.RemoveName("raw_char");
			temp.AddInt32("raw_char", (int32) nextChar);
			temp.RemoveName("byte");
 
			int32 override = -1;
			for (int32 j = fOverrideOffsets.CountItems()-1; j >= 0; j--) {
				int32 offset = (int32)(addr_t) fOverrideOffsets.ItemAt(j);
				if (offset == i) {
					override = (int32)(addr_t) fOverrides.ItemAt(j);
					break;
				}
			}
 
			char t[4];
			if (override >= 0) {
				if (override < 0x80) {
					// one-byte encoding
					t[0] = (char) override;
					t[1] = 0x00;
				} else if (override < 0x800) {
					// two-byte encoding
					t[0] = 0xC0 | ((char)((override & 0x7C0)>>6));
					t[1] = 0x80 | ((char)((override & 0x03F)>>0));
					t[2] = 0x00;
				} else {
					// three-byte encoding
					t[0] = 0xE0 | ((char)((override & 0xF000)>>12));
					t[1] = 0x80 | ((char)((override & 0x0FC0)>>6));
					t[2] = 0x80 | ((char)((override & 0x003F)>>0));
					t[3] = 0x00;
				}
			} else {
				t[0] = nextChar;
				t[1] = 0x00;
			}
 
			temp.RemoveName("byte");
 
			for (int m = 0; t[m] != 0x00; m++)
				temp.AddInt8("byte", t[m]);
 
			temp.RemoveName("states");
			temp.AddData("states", B_UINT8_TYPE, &fStates[i * 16], 16, true, 16);
			temp.RemoveName("bytes");
			temp.AddString("bytes", t);
			temp.what = B_KEY_DOWN;
			outList->AddItem(new BMessage(temp));
			temp.what = B_KEY_UP;
			outList->AddItem(new BMessage(temp));
		}
 
		return B_DISPATCH_MESSAGE;
	} else
		return B_SKIP_MESSAGE;
}
 
 
BArchivable*
KeyStrokeSequenceCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "KeyStrokeSequenceCommandActuator"))
		return new KeyStrokeSequenceCommandActuator(from);
	else
		return NULL;
}
 
 
//	#pragma mark - MIMEHandlerCommandActuator
 
 
MIMEHandlerCommandActuator::MIMEHandlerCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv),
	fMimeType((argc > 1) ? argv[1] : "")
{
}
 
 
MIMEHandlerCommandActuator::MIMEHandlerCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
	const char* temp;
	if (from->FindString("mimeType", 0, &temp) == B_OK)
		fMimeType = temp;
}
 
 
MIMEHandlerCommandActuator::~MIMEHandlerCommandActuator()
{
}
 
 
status_t
MIMEHandlerCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
	into->AddString("mimeType", fMimeType.String());
	return ret;
}
 
 
filter_result
MIMEHandlerCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage))
		// cause KeyEventAsync() to be called asynchronously
		*setAsyncData = (void*) true;
	return B_SKIP_MESSAGE;
}
 
 
void
MIMEHandlerCommandActuator::KeyEventAsync(const BMessage* keyMessage,
	void* asyncData)
{
	if (be_roster == NULL)
		return;
 
	BString string;
	status_t ret = be_roster->Launch(fMimeType.String());
	if ((ret != B_OK) && (ret != B_ALREADY_RUNNING)) {
		string << "Can't launch handler for ";
		string << ", no such MIME type exists. Please check your Shortcuts";
		string << " settings.";
		BAlert* alert = new BAlert("Shortcuts MIME launcher error",
			string.String(), "OK");
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go(NULL);
	}
}
 
 
BArchivable* MIMEHandlerCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MIMEHandlerCommandActuator"))
		return new MIMEHandlerCommandActuator(from);
	else
		return NULL;
}
 
 
//	#pragma mark - BeepCommandActuator
 
 
BeepCommandActuator::BeepCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv)
{
}
 
 
BeepCommandActuator::BeepCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
}
 
 
BeepCommandActuator::~BeepCommandActuator()
{
}
 
 
status_t
BeepCommandActuator::Archive(BMessage* into, bool deep) const
{
	return CommandActuator::Archive(into, deep);
}
 
 
BArchivable*
BeepCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "BeepCommandActuator"))
		return new BeepCommandActuator(from);
	else
		return NULL;
}
 
 
filter_result
BeepCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage))
		beep();
 
	return B_SKIP_MESSAGE;
}
 
 
//	#pragma mark - MultiCommandActuator
 
 
MultiCommandActuator::MultiCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
	BMessage msg;
	for (int i = 0; from->FindMessage("subs", i, &msg) == B_OK; i++) {
		BArchivable* subObj = instantiate_object(&msg);
		if (subObj) {
			CommandActuator* ca = dynamic_cast < CommandActuator*>(subObj);
 
			if (ca)
				fSubActuators.AddItem(ca);
			else
				delete subObj;
		}
	}
}
 
 
MultiCommandActuator::MultiCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv)
{
	for (int i = 1; i < argc; i++) {
		CommandActuator* sub = CreateCommandActuator(argv[i]);
 
		if (sub)
			fSubActuators.AddItem(sub);
		else
			printf("Error creating subActuator from [%s]\n", argv[i]);
	}
}
 
 
MultiCommandActuator::~MultiCommandActuator()
{
	int numSubs = fSubActuators.CountItems();
	for (int i = 0; i < numSubs; i++)
		delete ((CommandActuator*) fSubActuators.ItemAt(i));
}
 
 
status_t
MultiCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
	if (ret != B_OK)
		return ret;
 
	int numSubs = fSubActuators.CountItems();
	for (int i = 0; i < numSubs; i++) {
		BMessage msg;
		ret = ((CommandActuator*)fSubActuators.ItemAt(i))->Archive(&msg, deep);
 
		if (ret != B_OK)
			return ret;
 
		into->AddMessage("subs", &msg);
	}
	return B_OK;
}
 
 
BArchivable*
MultiCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MultiCommandActuator"))
		return new MultiCommandActuator(from);
	else
		return NULL;
}
 
 
filter_result
MultiCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** asyncData, BMessage* mouseMessage)
{
	BList* aDataList = NULL; // demand-allocated
	filter_result res = B_SKIP_MESSAGE;
	int numSubs = fSubActuators.CountItems();
	for (int i = 0; i < numSubs; i++) {
		void* aData = NULL;
		status_t next = ((CommandActuator*)fSubActuators.ItemAt(i))->
			KeyEvent(keyMessage, outList, &aData, mouseMessage);
 
		if (next == B_DISPATCH_MESSAGE)
			// dispatch message if at least one sub wants it dispatched
			res = B_DISPATCH_MESSAGE;
 
		if (aData) {
			if (aDataList == NULL)
				*asyncData = aDataList = new BList;
 
			while (aDataList->CountItems() < i - 1)
				aDataList->AddItem(NULL);
			aDataList->AddItem(aData);
		}
	}
	return res;
}
 
 
void
MultiCommandActuator::KeyEventAsync(const BMessage* keyUpMsg, void* asyncData)
{
	BList* list = (BList*) asyncData;
	int numSubs = list->CountItems();
	for (int i = 0; i < numSubs; i++) {
		void* aData = list->ItemAt(i);
		if (aData)
			((CommandActuator*) fSubActuators.ItemAt(i))->
				KeyEventAsync(keyUpMsg, aData);
	}
	delete list;
}
 
 
//	#pragma mark - MoveMouseCommandActuator
 
 
MoveMouseCommandActuator::MoveMouseCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
	if (from->FindFloat("xPercent", &fXPercent) != B_OK)
		fXPercent = 0.0f;
 
	if (from->FindFloat("yPercent", &fYPercent) != B_OK)
		fYPercent = 0.0f;
 
	if (from->FindFloat("xPixels", &fXPixels) != B_OK)
		fXPixels = 0;
 
	if (from->FindFloat("yPixels", &fYPixels) != B_OK)
		fYPixels = 0;
}
 
 
MoveMouseCommandActuator::MoveMouseCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv),
	fXPercent(0.0f),
	fYPercent(0.0f),
	fXPixels(0),
	fYPixels(0)
{
	if (argc > 1)
		_ParseArg(argv[1], fXPercent, fXPixels);
 
	if (argc > 2)
		_ParseArg(argv[2], fYPercent, fYPixels);
}
 
 
MoveMouseCommandActuator::~MoveMouseCommandActuator()
{
}
 
 
status_t
MoveMouseCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
	into->AddFloat("xPercent", fXPercent);
	into->AddFloat("yPercent", fYPercent);
	into->AddFloat("xPixels", fXPixels);
	into->AddFloat("yPixels", fYPixels);
	return ret;
}
 
 
void
MoveMouseCommandActuator::CalculateCoords(float& setX, float& setY) const
{
	BScreen s;
	BRect frame = s.Frame();
	setX = (frame.Width() * fXPercent) + fXPixels;
	setY = (frame.Height() * fYPercent) + fYPixels;
}
 
 
BMessage*
MoveMouseCommandActuator::CreateMouseMessage(const BMessage* original,
	BPoint where, BList* outList) const
{
	// Force where into the screen space
	{
		BScreen screen;
		where.ConstrainTo(screen.Frame());
	}
 
	BMessage* newMessage = new BMessage(B_MOUSE_MOVED);
 
	newMessage->AddPoint("where", where);
 
	int32 buttons = 0;
	(void)original->FindInt32("buttons", &buttons);
 
	if (buttons == 0)
		buttons = 1;
 
	newMessage->AddInt32("buttons", buttons);
 
	// Trey sez you gotta keep then "when"'s increasing if you want click&drag
	// to work!
	const BMessage* lastMessage;
	int32 last = outList->CountItems() - 1;
 
	if (outList->CountItems() > 0)
		lastMessage = (const BMessage*)outList->ItemAt(last);
	else
		lastMessage = original;
 
	int64 when;
 
	if (lastMessage->FindInt64("when", &when) == B_OK) {
		when++;
		newMessage->RemoveName("when");
		newMessage->AddInt64("when", when);
	}
	return newMessage;
}
 
 
static bool IsNumeric(char c);
static bool IsNumeric(char c)
{
	return (((c >= '0') && (c <= '9')) || (c == '.') || (c == '-'));
}
 
 
// Parse a string of the form "10", "10%", "10+ 10%", or "10%+ 10"
void
MoveMouseCommandActuator::_ParseArg(const char* arg, float& setPercent,
	float& setPixels) const
{
	char* temp = new char[strlen(arg) + 1];
	strcpy(temp, arg);
 
	// Find the percent part, if any
	char* percent = strchr(temp, '%');
	if (percent) {
		// Rewind to one before the beginning of the number
		char* beginNum = percent - 1;
		while (beginNum >= temp) {
			char c = *beginNum;
			if (IsNumeric(c))
				beginNum--;
			else
				break;
		}
 
		// parse the number
		setPercent = atof(++beginNum)/100.0f;
 
		// Now white it out to ease finding the other #
		while (beginNum <= percent)
			*(beginNum++) = ' ';
	}
 
	// Find the pixel part, if any
	char* pixel = temp;
	while (!IsNumeric(*pixel)) {
		if (*pixel == '\0')
			break;
		pixel++;
	}
	setPixels = atof(pixel);
 delete [] temp;
}
 
 
//	#pragma mark - MoveMouseToCommandActuator
 
 
MoveMouseToCommandActuator::MoveMouseToCommandActuator(BMessage* from)
	:
	MoveMouseCommandActuator(from)
{
}
 
 
MoveMouseToCommandActuator::MoveMouseToCommandActuator(int32 argc, char** argv)
	:
	MoveMouseCommandActuator(argc, argv)
{
}
 
 
MoveMouseToCommandActuator::~MoveMouseToCommandActuator()
{
}
 
 
status_t
MoveMouseToCommandActuator::Archive(BMessage* into, bool deep) const
{
	return MoveMouseCommandActuator::Archive(into, deep);
}
 
 
BArchivable*
MoveMouseToCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MoveMouseToCommandActuator"))
		return new MoveMouseToCommandActuator(from);
	else
		return NULL;
}
 
 
filter_result
MoveMouseToCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage)) {
		float x, y;
		CalculateCoords(x, y);
		BPoint where(x, y);
		BMessage* newMessage = CreateMouseMessage(keyMessage, where, outList);
		*mouseMessage = *newMessage;
		outList->AddItem(newMessage);
 
		return B_DISPATCH_MESSAGE;
	}
 
	return B_SKIP_MESSAGE;
}
 
 
//	#pragma mark - MoveMouseByCommandActuator
 
 
MoveMouseByCommandActuator::MoveMouseByCommandActuator(BMessage* from)
	:
	MoveMouseCommandActuator(from)
{
}
 
 
MoveMouseByCommandActuator::MoveMouseByCommandActuator(int32 argc, char** argv)
	:
	MoveMouseCommandActuator(argc, argv)
{
}
 
 
MoveMouseByCommandActuator::~MoveMouseByCommandActuator()
{
}
 
 
status_t MoveMouseByCommandActuator::Archive(BMessage* into, bool deep) const
{
 status_t ret = MoveMouseCommandActuator::Archive(into, deep);
 return ret;
}
 
 
BArchivable*
MoveMouseByCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "MoveMouseByCommandActuator"))
		return new MoveMouseByCommandActuator(from);
	else
		return NULL;
}
 
 
filter_result
MoveMouseByCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage)) {
		// Get the current mouse position
		BPoint where;
		if (mouseMessage->FindPoint("where", &where) == B_OK) {
			// Get the desired offset
			BPoint diff;
			CalculateCoords(diff.x, diff.y);
			where += diff;
			BMessage* newMessage = CreateMouseMessage(keyMessage, where, outList);
			*mouseMessage = *newMessage;
			outList->AddItem(newMessage);
			return B_DISPATCH_MESSAGE;
		}
	}
	return B_SKIP_MESSAGE;
}
 
 
//	#pragma mark - SendMessageCommandActuator
 
 
SendMessageCommandActuator::SendMessageCommandActuator(int32 argc, char** argv)
	:
	CommandActuator(argc, argv),
	fSignature((argc > 1) ? argv[1] : "")
{
	// Parse the what code. It may be in any of the following formats:
	// 12356 (int)
	// 'HELO' (chars enclosed in single quotes)
	// 0x12ab3c (hex)
 
	if (argc > 2) {
		const char* whatStr = argv[2];
		if ((whatStr[0] == '\'')
			&& (strlen(whatStr) == 6)
			&& (whatStr[5] == '\'')) {
			// Translate the characters into the uint32 they stand for.
			// Note that we must do this in a byte-endian-independant fashion
			// (no casting!)
			fSendMessage.what = 0;
			uint32 mult = 1;
			for (int i = 0; i < 4; i++) {
				fSendMessage.what += ((uint32)(whatStr[4 - i]))* mult;
				mult <<= 8;
			}
		} else if (strncmp(whatStr, "0x", 2) == 0)
			// translate hex string to decimal
			fSendMessage.what = strtoul(&whatStr[2], NULL, 16);
		else
			fSendMessage.what = atoi(whatStr);
	} else
		fSendMessage.what = 0;
 
	for (int i = 3; i < argc; i++) {
		type_code tc = B_BOOL_TYPE;// default type when no value is present
		const char* arg = argv[i];
		BString argString(arg);
		const char* equals = strchr(arg, '=');
		const char* value = "true";// default if no value is present
 
		if (equals) {
			tc = B_STRING_TYPE;// default type when value is present
			value = equals + 1;
			const char* colon = strchr(arg, ':');
			if (colon > equals)
				colon = NULL;// colons after the equals sign don't count
 
			if (colon) {
				const char* typeStr = colon + 1;
				if (strncasecmp(typeStr, "string", 6) == 0)
					tc = B_STRING_TYPE;
				else if (strncasecmp(typeStr, "int8", 4) == 0)
					tc = B_INT8_TYPE;
				else if (strncasecmp(typeStr, "int16", 5) == 0)
					tc = B_INT16_TYPE;
				else if (strncasecmp(typeStr, "int32", 5) == 0)
					tc = B_INT32_TYPE;
				else if (strncasecmp(typeStr, "int64", 5) == 0)
					tc = B_INT64_TYPE;
				else if (strncasecmp(typeStr, "bool", 4) == 0)
					tc = B_BOOL_TYPE;
				else if (strncasecmp(typeStr, "float", 5) == 0)
					tc = B_FLOAT_TYPE;
				else if (strncasecmp(typeStr, "double", 6) == 0)
					tc = B_DOUBLE_TYPE;
				else if (strncasecmp(typeStr, "point", 5) == 0)
					tc = B_POINT_TYPE;
				else if (strncasecmp(typeStr, "rect", 4) == 0)
					tc = B_RECT_TYPE;
 
				// remove the colon and stuff
				argString = argString.Truncate(colon - arg);
			} else
				// remove the equals and arg
				argString = argString.Truncate(equals - arg);
		}
 
		switch(tc) {
			case B_STRING_TYPE:
				fSendMessage.AddString(argString.String(), value);
				break;
 
			case B_INT8_TYPE:
				fSendMessage.AddInt8(argString.String(), (int8)atoi(value));
				break;
 
			case B_INT16_TYPE:
				fSendMessage.AddInt16(argString.String(), (int16)atoi(value));
				break;
 
			case B_INT32_TYPE:
				fSendMessage.AddInt32(argString.String(), (int32)atoi(value));
				break;
 
			case B_INT64_TYPE:
				fSendMessage.AddInt64(argString.String(), (int64)atoi(value));
				break;
 
			case B_BOOL_TYPE:
				fSendMessage.AddBool(argString.String(), ((value[0] == 't')
					|| (value[0] == 'T')));
				break;
 
			case B_FLOAT_TYPE:
				fSendMessage.AddFloat(argString.String(), atof(value));
				break;
 
			case B_DOUBLE_TYPE:
				fSendMessage.AddDouble(argString.String(), (double)atof(value));
				break;
 
			case B_POINT_TYPE:
			{
				float pts[2] = {0.0f, 0.0f};
				_ParseFloatArgs(pts, 2, value);
				fSendMessage.AddPoint(argString.String(), BPoint(pts[0], pts[1]));
				break;
			}
 
			case B_RECT_TYPE:
			{
				float pts[4] = {0.0f, 0.0f, 0.0f, 0.0f};
				_ParseFloatArgs(pts, 4, value);
				fSendMessage.AddRect(argString.String(),
					BRect(pts[0], pts[1], pts[2], pts[3]));
				break;
			}
		}
	}
}
 
 
void
SendMessageCommandActuator::_ParseFloatArgs(float* args, int maxArgs,
	const char* str) const
{
	const char* next = str;
	for (int i = 0; i < maxArgs; i++) {
		args[i] = atof(next);
		next = strchr(next, ',');
		if (next) next++;
		else break;
	}
}
 
 
SendMessageCommandActuator::SendMessageCommandActuator(BMessage* from)
	:
	CommandActuator(from)
{
	const char* temp;
 
	if (from->FindString("signature", 0, &temp) == B_OK)
		fSignature = temp;
 
	(void) from->FindMessage("sendmsg", &fSendMessage);
}
 
 
SendMessageCommandActuator::~SendMessageCommandActuator()
{
}
 
 
status_t
SendMessageCommandActuator::Archive(BMessage* into, bool deep) const
{
	status_t ret = CommandActuator::Archive(into, deep);
	into->AddString("signature", fSignature.String());
	into->AddMessage("sendmsg", &fSendMessage);
	return ret;
}
 
 
filter_result
SendMessageCommandActuator::KeyEvent(const BMessage* keyMessage, BList* outList,
	void** setAsyncData, BMessage* mouseMessage)
{
	if (IS_KEY_DOWN(keyMessage))
		// cause KeyEventAsync() to be called asynchronously
		*setAsyncData = (void*) true;
 
	return B_SKIP_MESSAGE;
}
 
 
void
SendMessageCommandActuator::KeyEventAsync(const BMessage* keyMessage,
	void* asyncData)
{
	if (be_roster == NULL)
		return;
 
	BString string;
	if (fSignature.Length() == 0) {
		string << "SendMessage: Target application signature not specified";
		BAlert* alert = new BAlert("Shortcuts SendMessage error",
			string.String(), "OK");
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go(NULL);
	} else {
		status_t result = B_OK;
		BMessenger messenger(fSignature.String(), -1, &result);
		if (result == B_OK)
			messenger.SendMessage(&fSendMessage);
	}
}
 
 
BArchivable*
SendMessageCommandActuator::Instantiate(BMessage* from)
{
	if (validate_instantiation(from, "SendMessageCommandActuator"))
		return new SendMessageCommandActuator(from);
	else
		return NULL;
}