bool
RemoteDrawingEngine::_DrawingEngineResult(void* cookie, RemoteMessage& message)
{
RemoteDrawingEngine* engine = (RemoteDrawingEngine*)cookie;
switch (message.Code()) {
case RP_DRAW_STRING_RESULT:
if (message.Read(engine->fDrawStringResult) != B_OK)
return false;
break;
case RP_STRING_WIDTH_RESULT:
if (message.Read(engine->fStringWidthResult) != B_OK)
return false;
break;
case RP_READ_BITMAP_RESULT:
if (message.ReadBitmap(&engine->fReadBitmapResult) != B_OK)
return false;
break;
default:
return false;
}
release_sem(engine->fResultNotify);
return true;
}
bool
RemoteEventStream::EventReceived(RemoteMessage& message)
{
uint16 code = message.Code();
uint32 what = 0;
switch (code) {
case RP_MOUSE_MOVED:
what = B_MOUSE_MOVED;
break;
case RP_MOUSE_DOWN:
what = B_MOUSE_DOWN;
break;
case RP_MOUSE_UP:
what = B_MOUSE_UP;
break;
case RP_MOUSE_WHEEL_CHANGED:
what = B_MOUSE_WHEEL_CHANGED;
break;
case RP_KEY_DOWN:
what = B_KEY_DOWN;
break;
case RP_KEY_UP:
what = B_KEY_UP;
break;
case RP_MODIFIERS_CHANGED:
what = B_MODIFIERS_CHANGED;
break;
}
if (what == 0)
return false;
BMessage* event = new BMessage(what);
if (event == NULL)
return false;
event->AddInt64("when", system_time());
switch (code) {
case RP_MOUSE_MOVED:
case RP_MOUSE_DOWN:
case RP_MOUSE_UP:
{
message.Read(fMousePosition);
if (code != RP_MOUSE_MOVED)
message.Read(fMouseButtons);
event->AddPoint("where", fMousePosition);
event->AddInt32("buttons", fMouseButtons);
event->AddInt32("modifiers", fModifiers);
if (code == RP_MOUSE_DOWN) {
int32 clicks;
if (message.Read(clicks) == B_OK)
event->AddInt32("clicks", clicks);
}
if (code == RP_MOUSE_MOVED)
fLatestMouseMovedEvent = event;
break;
}
case RP_MOUSE_WHEEL_CHANGED:
{
float xDelta, yDelta;
message.Read(xDelta);
message.Read(yDelta);
event->AddFloat("be:wheel_delta_x", xDelta);
event->AddFloat("be:wheel_delta_y", yDelta);
break;
}
case RP_KEY_DOWN:
case RP_KEY_UP:
{
int32 numBytes;
if (message.Read(numBytes) != B_OK)
break;
char* bytes = (char*)malloc(numBytes + 1);
if (bytes == NULL)
break;
if (message.ReadList(bytes, numBytes) != B_OK)
break;
for (int32 i = 0; i < numBytes; i++)
event->AddInt8("byte", (int8)bytes[i]);
bytes[numBytes] = 0;
event->AddData("bytes", B_STRING_TYPE, bytes, numBytes + 1, false);
event->AddInt32("modifiers", fModifiers);
int32 rawChar;
if (message.Read(rawChar) == B_OK)
event->AddInt32("raw_char", rawChar);
int32 key;
if (message.Read(key) == B_OK)
event->AddInt32("key", key);
break;
}
case RP_MODIFIERS_CHANGED:
{
event->AddInt32("be:old_modifiers", fModifiers);
message.Read(fModifiers);
event->AddInt32("modifiers", fModifiers);
break;
}
}
BAutolock lock(fEventListLocker);
fEventList.AddItem(event);
if (fWaitingOnEvent) {
fWaitingOnEvent = false;
lock.Unlock();
release_sem(fEventNotification);
}
return true;
}
bool Processor::Network::SendMessage(const RemoteMessage& msg)
{
assert(msg.type != RemoteMessage::MSG_NONE);
// Delegated message
DelegateMessage dmsg;
(RemoteMessage&)dmsg = msg;
dmsg.src = m_parent.GetPID();
// Get destination
switch (msg.type)
{
case RemoteMessage::MSG_ALLOCATE:
case RemoteMessage::MSG_BUNDLE: dmsg.dest = msg.allocate.place.pid; break;
case RemoteMessage::MSG_SET_PROPERTY: dmsg.dest = msg.property.fid.pid; break;
case RemoteMessage::MSG_CREATE: dmsg.dest = msg.create.fid.pid; break;
case RemoteMessage::MSG_DETACH: dmsg.dest = msg.detach.fid.pid; break;
case RemoteMessage::MSG_SYNC: dmsg.dest = msg.sync.fid.pid; break;
case RemoteMessage::MSG_RAW_REGISTER: dmsg.dest = msg.rawreg.pid; break;
case RemoteMessage::MSG_FAM_REGISTER: dmsg.dest = msg.famreg.fid.pid; break;
case RemoteMessage::MSG_BREAK: dmsg.dest = msg.brk.pid; break;
default: dmsg.dest = INVALID_PID; break;
}
assert(dmsg.dest != INVALID_PID);
if (dmsg.dest == dmsg.src)
{
if (GetKernel()->GetActiveProcess() == &p_DelegationIn)
{
/*
This response is meant for us as a result of an input message.
To avoid having to go to the output buffer, and then into this
input buffer again, we forcibly overwrite the contents of the input
register with the response.
This is also necessary to avoid a circular dependency on the output buffer.
*/
m_delegateIn.Simulator::Register<DelegateMessage>::Write(dmsg);
// Return here to avoid clearing the input buffer. We want to process this
// response next cycle.
return SUCCESS;
}
if (!m_delegateIn.Write(dmsg))
{
DeadlockWrite("Unable to buffer local network message to loopback %s", msg.str().c_str());
return false;
}
DebugNetWrite("sent delegation message to loopback %s", msg.str().c_str());
}
else
{
if (!m_delegateOut.Write(dmsg))
{
DeadlockWrite("Unable to buffer remote network message for CPU%u %s", (unsigned)dmsg.dest, msg.str().c_str());
return false;
}
DebugNetWrite("sent delegation message to CPU%u %s", (unsigned)dmsg.dest, msg.str().c_str());
}
return true;
}
