void BWebPage::skipToLastMessage(BMessage*& message)
{
// NOTE: All messages that are fast-forwarded like this
// need to be flagged with the intended target BWebPage,
// or else we steal or process messages intended for another
// BWebPage here!
bool first = true;
BMessageQueue* queue = Looper()->MessageQueue();
int32 index = 0;
while (BMessage* nextMessage = queue->FindMessage(message->what, index)) {
BHandler* target = 0;
nextMessage->FindPointer("target", reinterpret_cast<void**>(&target));
if (target != this) {
index++;
continue;
}
if (!first)
delete message;
message = nextMessage;
queue->RemoveMessage(message);
first = false;
}
}
void ArpRemoteTerminal::MessageReceived(BMessage *message)
{
ArpD(cdb << ADH << "ArpRemoteTerminal::MessageReceived: " << *message << endl);
switch( message->what ) {
case TERM_XFER_TEXT_MSG: {
#if 1
const ichar* txt = NULL;
long len=0;
int32 idx=0;
while( message->FindData("text", B_ASCII_TYPE, idx,
(const void**)&txt, &len) == B_NO_ERROR ) {
if( txt && len > 0 ) {
Emulator().EmulateToTTY(txt,len);
}
idx++;
}
message->SendReply(B_NO_REPLY);
#else
int32 recpos = 0;
BMessage* curmsg = Window()->DetachCurrentMessage();
BMessageQueue* queue = Window()->MessageQueue();
while( curmsg ) {
ichar* txt = NULL;
long len=0;
int32 idx=0;
while( curmsg->FindData("text", B_ASCII_TYPE, idx,
&txt, &len) == B_NO_ERROR ) {
if( txt ) {
if( recpos + len > sizeof(receiveBuffer) ) {
if( recpos > 0 ) {
Emulator().EmulateToTTY(&receiveBuffer[0],recpos);
recpos = 0;
}
}
if( len > sizeof(receiveBuffer) ) {
Emulator().EmulateToTTY(txt,len);
} else {
memcpy(&receiveBuffer[recpos],txt,len);
recpos += len;
}
}
idx++;
}
delete curmsg;
curmsg = NULL;
if( queue ) {
curmsg = queue->FindMessage((int32)0);
if( curmsg &&
curmsg->what == TERM_XFER_TEXT_MSG ) {
curmsg = queue->NextMessage();
} else curmsg = NULL;
}
}
if( recpos > 0 ) {
Emulator().EmulateToTTY(&receiveBuffer[0],recpos);
}
return;
#endif
} break;
case TERM_RESET_MSG: {
bool hard = false;
if( message->FindBool("hard", &hard) != B_OK ) hard = false;
Emulator().Reset(hard);
TermClean();
// HACK: The emulator often changes the terminal's mode
// flags after calling its reset, leaving any active
// settings view with incorrect settings. Until we can
// do better at tracking state changes, for this situation
// send another update to the settings view.
if( HaveWatchers() ) {
BMessage config;
if( GetConfiguration(&config) == B_NO_ERROR ) {
ArpD(cdb << ADH << "Reporting change: " << config << endl);
ReportChange(&config);
}
}
} break;
case TERM_START_SESSION_MSG: {
StartSession();
TermClean();
Owner().SendMessage(message);
} break;
case TERM_END_SESSION_MSG: {
EndSession();
TermClean();
Owner().SendMessage(message);
} break;
case TERM_REQUEST_STATUS_MSG: {
int32 rows,cols;
TermGetSize(&rows,&cols);
SendSizeMsg(rows,cols);
SendEmulatorsMsg();
} break;
case TERM_WINDOW_SIZE_MSG: {
int32 rows,cols;
TermGetFixedSize(&rows,&cols);
message->FindInt32("rows",&rows);
message->FindInt32("columns",&cols);
TermSetFixedSize(rows,cols);
} break;
case TERM_SELECT_EMULATION_MSG: {
BMenuItem* item = NULL;
if( message->FindPointer("source",(void**)&item) ) item = NULL;
BMenu* menu = NULL;
if( item ) menu = item->Menu();
int32 num=0;
type_code type;
if( !message->GetInfo("name",&type,&num) ) {
for( int i=0; i<num; i++ ) {
const char* str;
if( !message->FindString("name",i,&str) ) {
delete SetEmulator(str);
if( !IsDefaultEmulator() ) {
if( menu ) CheckEmulationMenu(menu);
return;
}
}
}
}
if( menu ) CheckEmulationMenu(menu);
} break;
case ARP_PUT_CONFIGURATION_MSG: {
BMessage config;
if( message->FindMessage("settings",&config) == B_NO_ERROR ) {
PutConfiguration(&config);
} else {
inherited::MessageReceived(message);
}
} break;
case TERM_ADD_WATCHER_MSG: {
BMessenger w;
if( message->FindMessenger("watch",&w) == B_NO_ERROR ) {
AddWatcher(w);
BMessage config;
if( GetConfiguration(&config) == B_NO_ERROR ) {
ReportChange(&config, &w);
}
} else {
inherited::MessageReceived(message);
}
} break;
case TERM_REM_WATCHER_MSG: {
BMessenger w;
if( message->FindMessenger("watch",&w) == B_NO_ERROR ) {
RemWatcher(w);
} else {
inherited::MessageReceived(message);
}
} break;
default:
inherited::MessageReceived(message);
}
}
void
ObjectView::MessageReceived(BMessage *inMsg)
{
BPoint delta(0, 0), where(0, 0);
if (inMsg->WasDropped()) {
where = inMsg->DropPoint(&delta);
ConvertFromScreen(&where);
}
switch (inMsg->what) {
case REDISPLAY_OBJECT: {
BRect r;
BMessageQueue *q = Window()->MessageQueue();
BMessage *m=nullptr;
if (inMsg->HasRect("rect")) {
r = inMsg->FindRect("rect");
} else {
r = Bounds();
}
for (int count=0; m=q->FindMessage(REDISPLAY_OBJECT, count); count++) {
ObjectView *ov=nullptr;
m->FindPointer("object", (void**)&ov);
if (ov == this) {
BRect s;
if (m->HasRect("rect")) {
s = m->FindRect("rect");
s.left = Min(s.left,r.left);
s.right = Max(s.right, r.right);
m->ReplaceRect("rect", s);
} else {
s = r;
m->AddRect("rect", s);
}
return;
}
}
Draw(r);
break;
}
case SET_COLOR: {
rgb_color *p;
ssize_t sz;
inMsg->FindData("color", B_RAW_TYPE, (const void **)&p, &sz);
color.red = p->red;
color.green = p->green;
color.blue = p->blue;
ReDraw();
break;
}
case SET_DISPLAY_MODE: {
rgb_color *p;
int32 md = inMsg->FindInt32("display mode");
SetDisplayMode(md);
break;
}
default:
BView::MessageReceived(inMsg);
break;
}
}
void BWebPage::MessageReceived(BMessage* message)
{
switch (message->what) {
case HANDLE_SHUTDOWN:
// NOTE: This message never arrives here when the BApplication is already
// processing B_QUIT_REQUESTED. Then the view will be detached and instruct
// the BWebPage handler to shut itself down, but BApplication will not
// process additional messages. That's why the windows containing WebViews
// are detaching the views already in their QuitRequested() hooks and
// LauncherApp calls these hooks already in its own QuitRequested() hook.
Looper()->RemoveHandler(this);
delete this;
// TOAST!
return;
case HANDLE_LOAD_URL:
handleLoadURL(message);
break;
case HANDLE_RELOAD:
handleReload(message);
break;
case HANDLE_GO_BACK:
handleGoBack(message);
break;
case HANDLE_GO_FORWARD:
handleGoForward(message);
break;
case HANDLE_STOP_LOADING:
handleStop(message);
break;
case HANDLE_SET_VISIBLE:
handleSetVisible(message);
break;
case HANDLE_DRAW: {
bool first = true;
BMessageQueue* queue = Looper()->MessageQueue();
BRect updateRect;
message->FindRect("update rect", &updateRect);
int32 index = 0;
while (BMessage* nextMessage = queue->FindMessage(message->what, index)) {
BHandler* target = 0;
nextMessage->FindPointer("target", reinterpret_cast<void**>(&target));
if (target != this) {
index++;
continue;
}
if (!first) {
delete message;
first = false;
}
message = nextMessage;
queue->RemoveMessage(message);
BRect rect;
message->FindRect("update rect", &rect);
updateRect = updateRect | rect;
}
paint(updateRect, false);
break;
}
case HANDLE_FRAME_RESIZED:
skipToLastMessage(message);
handleFrameResized(message);
break;
case HANDLE_FOCUSED:
handleFocused(message);
break;
case HANDLE_ACTIVATED:
handleActivated(message);
break;
case B_MOUSE_MOVED:
skipToLastMessage(message);
// fall through
case B_MOUSE_DOWN:
case B_MOUSE_UP:
handleMouseEvent(message);
break;
case B_MOUSE_WHEEL_CHANGED:
handleMouseWheelChanged(message);
break;
case B_KEY_DOWN:
case B_KEY_UP:
handleKeyEvent(message);
break;
case HANDLE_CHANGE_ZOOM_FACTOR:
handleChangeZoomFactor(message);
break;
case HANDLE_FIND_STRING:
handleFindString(message);
break;
case HANDLE_SET_STATUS_MESSAGE: {
BString status;
if (message->FindString("string", &status) == B_OK)
setStatusMessage(status);
break;
}
case HANDLE_RESEND_NOTIFICATIONS:
handleResendNotifications(message);
break;
case HANDLE_SEND_EDITING_CAPABILITIES:
handleSendEditingCapabilities(message);
break;
case HANDLE_SEND_PAGE_SOURCE:
handleSendPageSource(message);
break;
case B_REFS_RECEIVED: {
RefPtr<FileChooser>* chooser;
if (message->FindPointer("chooser", reinterpret_cast<void**>(&chooser)) == B_OK) {
entry_ref ref;
BPath path;
Vector<String> filenames;
for (int32 i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
path.SetTo(&ref);
filenames.append(String(path.Path()));
}
(*chooser)->chooseFiles(filenames);
delete chooser;
}
break;
}
case B_CANCEL: {
int32 oldWhat;
BFilePanel* panel;
if (message->FindPointer("source", reinterpret_cast<void**>(&panel)) == B_OK
&& message->FindInt32("old_what", &oldWhat) == B_OK
&& oldWhat == B_REFS_RECEIVED) {
// TODO: Eventually it would be nice to reuse the same file panel...
// At least don't leak the file panel for now.
delete panel;
}
break;
}
default:
BHandler::MessageReceived(message);
}
}