/* We overwrite SetValue to send a message to the target everytime
the setting change and not only at the end. */
void CControl::SetValue(int32 color_value)
{
BHandler *handler;
BColorControl::SetValue(color_value);
handler = Target();
if (handler) {
BMessage msg;
msg.AddInt32("be:value", color_value);
handler->Looper()->PostMessage(&msg, handler);
}
}
void TorrentObject::TorrentMetadataCallback(tr_torrent* torrent, void* data)
{
TorrentObject* torrentObject = reinterpret_cast<TorrentObject*>(data);
BHandler* handler = torrentObject->fMetadataHandler;
//
//
//
if( handler == NULL )
return;
//
// Build the message.
//
if (BLooper* looper = handler->Looper())
looper->PostMessage(new BMessage(MSG_TRANSMISSION_METADATA_CALLBACK), handler);
}
void ArpNotificationType::NotifyDependents(BMessage *msg, bool deliverAsynchronously)
{
BHandler *h;
BLooper *looper;
for (long i=0; (h = (BHandler*)dependents.ItemAt(i)) != 0; i++) {
if (((looper = h->Looper()) != 0)
&& (looper->Lock())) {
// FIX: need to send out the message, and let the views
// invalidate themselves! So be aware that the Update
// implementation will ALWAYS be called from within this
// loop, meaning within a lock/unlock
#if 0 // Uncomment this to debug where messages are going
printf("SENDING MESSAGE TO %s\n", h->Name()); fflush(stdout);
#endif
h->MessageReceived(msg);
looper->Unlock();
}
}
}
void
BLooper::task_looper()
{
PRINT(("BLooper::task_looper()\n"));
// Check that looper is locked (should be)
AssertLocked();
// Unlock the looper
Unlock();
if (IsLocked())
debugger("looper must not be locked!");
// loop: As long as we are not terminating.
while (!fTerminating) {
PRINT(("LOOPER: outer loop\n"));
// TODO: timeout determination algo
// Read from message port (how do we determine what the timeout is?)
PRINT(("LOOPER: MessageFromPort()...\n"));
BMessage* msg = MessageFromPort();
PRINT(("LOOPER: ...done\n"));
// Did we get a message?
if (msg)
_AddMessagePriv(msg);
// Get message count from port
int32 msgCount = port_count(fMsgPort);
for (int32 i = 0; i < msgCount; ++i) {
// Read 'count' messages from port (so we will not block)
// We use zero as our timeout since we know there is stuff there
msg = MessageFromPort(0);
if (msg)
_AddMessagePriv(msg);
}
// loop: As long as there are messages in the queue and the port is
// empty... and we are not terminating, of course.
bool dispatchNextMessage = true;
while (!fTerminating && dispatchNextMessage) {
PRINT(("LOOPER: inner loop\n"));
// Get next message from queue (assign to fLastMessage after
// locking)
BMessage* message = fDirectTarget->Queue()->NextMessage();
Lock();
fLastMessage = message;
if (fLastMessage == NULL) {
// No more messages: Unlock the looper and terminate the
// dispatch loop.
dispatchNextMessage = false;
} else {
PRINT(("LOOPER: fLastMessage: 0x%lx: %.4s\n", fLastMessage->what,
(char*)&fLastMessage->what));
DBG(fLastMessage->PrintToStream());
// Get the target handler
BHandler* handler = NULL;
BMessage::Private messagePrivate(fLastMessage);
bool usePreferred = messagePrivate.UsePreferredTarget();
if (usePreferred) {
PRINT(("LOOPER: use preferred target\n"));
handler = fPreferred;
if (handler == NULL)
handler = this;
} else {
gDefaultTokens.GetToken(messagePrivate.GetTarget(),
B_HANDLER_TOKEN, (void**)&handler);
// if this handler doesn't belong to us, we drop the message
if (handler != NULL && handler->Looper() != this)
handler = NULL;
PRINT(("LOOPER: use %ld, handler: %p, this: %p\n",
messagePrivate.GetTarget(), handler, this));
}
// Is this a scripting message? (BMessage::HasSpecifiers())
if (handler != NULL && fLastMessage->HasSpecifiers()) {
int32 index = 0;
// Make sure the current specifier is kosher
if (fLastMessage->GetCurrentSpecifier(&index) == B_OK)
handler = resolve_specifier(handler, fLastMessage);
}
if (handler) {
// Do filtering
handler = _TopLevelFilter(fLastMessage, handler);
PRINT(("LOOPER: _TopLevelFilter(): %p\n", handler));
if (handler && handler->Looper() == this)
DispatchMessage(fLastMessage, handler);
}
}
if (fTerminating) {
// we leave the looper locked when we quit
return;
}
message = fLastMessage;
fLastMessage = NULL;
// Unlock the looper
Unlock();
// Delete the current message (fLastMessage)
if (message != NULL)
delete message;
// Are any messages on the port?
if (port_count(fMsgPort) > 0) {
// Do outer loop
dispatchNextMessage = false;
}
}
}
PRINT(("BLooper::task_looper() done\n"));
}