You can make the data structure that holds who registered for a message be a tree: each node has a list of objects listening for that message and a hash map of children, with each level becoming more specific. For example, when someone registers with the root node, they get all messages. The root node has two children in its hash map, triggerOnTouch and buttonActivated (or whatever other messages). When an object registers with the triggerOnTouch node, it only gets all triggerOnTouch events. The triggerOnTouch node's hash map contains the nodes for a specific triggerID, so when an object registers with it, it would get only triggerOnTouch events sent by something with that specific id.

Its kind of like a BHV tree, but for messages. I've used this before and it works really well both from a usability and performance standpoint.



class Message
{
unsigned int messageType;
unsigned int senderID;
}
class MessageNode
{
virtual void register(MessageReceiver* receiver, Message* messageToReceive)
{
if (messageToReceive->messageType == 0)
{
registeredReceivers.push_back(receiver);
}
else
{
std::map<unsigned int*, MessageNode*>::iterator iter;
iter = childNodes.find(messageToReceive->messageType);

if(iter == childNodes.end())
{
childNodes.insert(pair<unsigned int, MessageNode*>(messageToReceive->messageType, new MessageNodeType()));
iter = childNodes.find(messageToReceive->messageType);
}

(*iter).second.register(receiver, messageToReceive);
}
}
virtual void sendMessage(Message* message)
{
for each receiver in registeredReceivers
{
receiver.sendMessage(message)
}

MessageNode* node = childNodes[message->messageType].second;

if (node != NULL)
{
(*iter).second->sendMessage(message);
}
}

std::list<MessageReceiver*> registeredReceivers;
std::map<unsigned int*, MessageNode*> childNodes;
};
class MessageNodeType : public MessageNode
{
virtual void register(MessageReceiver* receiver, Message* messageToReceive)
{
if (messageToReceive->senderID == 0)
{
registeredReceivers.push_back(receiver);
}
else
{
std::map<unsigned int*, MessageNode*>::iterator iter;
iter = childNodes.find(messageToReceive->senderID);

if(iter == childNodes.end())
{
childNodes.insert(pair<unsigned int, MessageNode*>(messageToReceive->senderID, new MessageNodeID()));
iter = childNodes.find(messageToReceive->senderID);
}

(*iter).second.register(receiver, messageToReceive);
}
}

virtual void sendMessage(Message* message)
{
for each receiver in registeredReceivers
{
receiver.sendMessage(message)
}

std::map<unsigned int*, MessageNode>::iterator iter;
iter = childNodes.find(message->senderID);

if (iter != childNodes.end())
{
(*iter).second->sendMessage(message);
}
}
}



Message:
We use a hashed string for a lot of stuff, which is basically just a fancy unsigned int. messageType would be HashString("triggerOnTouch").hash
senderID is just whatever unique id you use to identify stuff.

MessageNode:
Base class for other message managing structures. Holds a map of children keyed by the type of message.
register - first, check the message type. If it is 0, the caller is registering for all messages, so add caller to the list of registered receivers. Otherwise, call register on appropriate child node, creating it if necessary.
sendMessage - send message to all objects in registeredReceivers list (objects that want all messages) and pass along to appropriate child node (the one which is in the map with a key matching messageType).

MessageNodeType:
Registered receivers all want a message of a certain type.
register - same as above, except the key is senderID instead of message type
sendMessage - same as above, except the key is senderID instead of message type

MessageNodeID: (not shown)
Registered receivers all want a message of a certain type from a certain sender. Same as other two classes, except doesn't have children (is a leaf node)

I just threw that together, you can make it much more elegant and simple by using comparison functions and templates rather than derived classes, and of course using something other than stl
That also allows you to use anything you write a comparison function for, you could have all messages from a certain sender (not possible above, only specific message from specific sender) or sending to all objects within x distance of location.