// -------------------------------------------------------------------
void
DPRegression::MessageReceived(BMessage* theMesg)
{
entry_ref theRef;
status_t status = B_OK;
switch (theMesg->what) {
case launch_mesg :
status = theMesg->FindRef("refs",&theRef);;
if(status == B_OK) {
mRegrWindow->OpenFile(&theRef,false);
}
mRegrWindow->PostMessage(FLDS_RESET);
break;
case mesg_mark : // A series of data to be marked
DetachCurrentMessage();
MarkData(theMesg);
break;
case set_display : // Data to be marked
SetDisplays(theMesg);
break;
case refresh_disp :
// mRegrDisplay->RefreshDisplays();
break;
default :
BApplication::MessageReceived(theMesg);
}
}
void
MediaConverterApp::MessageReceived(BMessage *msg)
{
switch (msg->what) {
case FILE_LIST_CHANGE_MESSAGE:
if (fWin->Lock()) {
bool enable = fWin->CountSourceFiles() > 0;
fWin->SetEnabled(enable, enable);
fWin->Unlock();
}
break;
case START_CONVERSION_MESSAGE:
if (!fConverting)
StartConverting();
break;
case CANCEL_CONVERSION_MESSAGE:
fCancel = true;
break;
case CONVERSION_DONE_MESSAGE:
fCancel = false;
fConverting = false;
DetachCurrentMessage();
BMessenger(fWin).SendMessage(msg);
break;
default:
BApplication::MessageReceived(msg);
}
}
void
WPASupplicantApp::MessageReceived(BMessage *message)
{
switch (message->what) {
case kMsgWPAJoinNetwork:
{
if (_CheckAskForConfig(message)) {
status_t status = wireless_config_dialog(*message);
if (status != B_OK) {
_SendReplyIfNeeded(*message, status);
return;
}
}
_EnqueueAndNotify(DetachCurrentMessage());
// The event processing code will send the reply.
return;
}
case kMsgWPALeaveNetwork:
{
_EnqueueAndNotify(DetachCurrentMessage());
// The event processing code will send the reply.
return;
}
case B_NETWORK_MONITOR:
{
BMessage *copy = new BMessage();
*copy = *message;
_EnqueueAndNotify(copy);
return;
}
case kMsgSupplicantStateChanged:
case kMsgJoinTimeout:
{
_NotifyInterfaceStateChanged(message);
return;
}
}
BApplication::MessageReceived(message);
}
void
NSBrowserApplication::ArgvReceived(int32 argc, char **argv)
{
NSBrowserWindow *win = nsbeos_find_last_window();
if (!win) {
return;
}
win->Unlock();
BMessage *message = DetachCurrentMessage();
nsbeos_pipe_message_top(message, win, win->Scaffolding());
}
void
NSBrowserApplication::RefsReceived(BMessage *message)
{
DetachCurrentMessage();
NSBrowserWindow *win = nsbeos_find_last_window();
if (!win) {
gFirstRefsReceived = message;
return;
}
win->Unlock();
nsbeos_pipe_message_top(message, win, win->Scaffolding());
}
void
PrintServerApp::Handle_BeOSR5_Message(BMessage* msg)
{
switch(msg->what) {
// Get currently selected printer
case PSRV_GET_ACTIVE_PRINTER: {
BMessage reply('okok');
BString printerName;
if (fDefaultPrinter)
printerName = fDefaultPrinter->Name();
BString mime;
if (fUseConfigWindow && MimeTypeForSender(msg, mime)) {
BAutolock lock(gLock);
if (lock.IsLocked()) {
// override with printer for application
PrinterSettings* p = fSettings->FindPrinterSettings(
mime.String());
if (p)
printerName = p->GetPrinter();
}
}
reply.AddString("printer_name", printerName);
// BeOS knows not if color or not, so always color
reply.AddInt32("color", BPrintJob::B_COLOR_PRINTER);
msg->SendReply(&reply);
}
break;
//make printer active (currently always quietly :))
case PSRV_MAKE_PRINTER_ACTIVE_QUIETLY:
//make printer active quietly
case PSRV_MAKE_PRINTER_ACTIVE: {
BString newActivePrinter;
if (msg->FindString("printer",&newActivePrinter) == B_OK) {
SelectPrinter(newActivePrinter.String());
}
}
break;
case PSRV_SHOW_PAGE_SETUP:
case PSRV_SHOW_PRINT_SETUP:
case PSRV_GET_DEFAULT_SETTINGS:
case PSRV_MAKE_PRINTER:
AsyncHandleMessage(DetachCurrentMessage());
break;
// Tell printer addon to print a spooled job
case PSRV_PRINT_SPOOLED_JOB:
HandleSpooledJobs();
break;
}
}
void
CannaLooper::_HandleKeyDown(BMessage* msg)
{
uint32 modifier;
int32 key;
msg->FindInt32("modifiers", (int32*)&modifier);
msg->FindInt32("key", &key);
if ((modifier & B_COMMAND_KEY) != 0) {
EnqueueMessage(DetachCurrentMessage());
return;
}
char character;
msg->FindInt8("byte", (int8*)&character);
// The if clause below is to avoid processing key input which char code
// is 0x80 or more.
// if mikakutei string exists, dispose current message.
// Otherwise, send it to application as usual B_KEY_DOWN message.
if ((character & 0x80) != 0) {
if (fCanna->MikakuteiLength() != 0)
delete DetachCurrentMessage();
else
EnqueueMessage(DetachCurrentMessage());
return;
}
SERIAL_PRINT(("CannaLooper: HandleKeyDown() calling "
"CannaInterface::KeyIn()...\n", result));
uint32 result = fCanna->KeyIn(character, modifier, key);
SERIAL_PRINT(("CannaLooper: HandleKeyDown() received result = %d from "
"CannaInterface.\n", result));
_ProcessResult(result);
}
void
TheApp::MessageReceived(BMessage* message)
{
switch (message->what) {
case CAYA_REPLICANT_STATUS_SET:
case CAYA_REPLICANT_SHOW_WINDOW:
case CAYA_SHOW_SETTINGS:
case CAYA_REPLICANT_MESSENGER:
DetachCurrentMessage();
fMainWin->PostMessage(message);
break;
case CAYA_REPLICANT_EXIT:
// TODO BAlert here
PostMessage(B_QUIT_REQUESTED);
break;
default:
BLooper::MessageReceived(message);
}
}
void
CannaLooper::_ProcessResult(uint32 result)
{
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing result = %d\n",
result));
if ((result & GUIDELINE_APPEARED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_APPEARED\n"));
if (fCanna->MikakuteiLength() != 0) {
// usual guideline i.e. kouho
BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_LOCATION_REQUEST);
fOwner->EnqueueMessage(msg);
SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST has "
"been sent\n"));
} else {
// guideline exists, but no mikakutei string - means extend mode
// and such.
SERIAL_PRINT((" GUIDELINE_APPEARED: calling "
"GenerateKouho()...\n"));
fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
SERIAL_PRINT((" GUIDELINE_APPEARED: posting KouhoMsg to "
"KouhoWindow %x...\n", fKouhoWindow));
fKouhoWindow->PostMessage(KOUHO_WINDOW_SHOW_ALONE);
}
}
if ((result & GUIDELINE_DISAPPEARED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_DISAPPEARED\n"));
fKouhoWindow->PostMessage(KOUHO_WINDOW_HIDE);
}
if ((result & MODE_CHANGED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"MODE_CHANGED\n"));
BMessage message(PALETTE_WINDOW_BUTTON_UPDATE);
message.AddInt32("mode", fCanna->GetMode());
fPaletteWindow->PostMessage(&message);
SERIAL_PRINT(("CannaLooper: PALETTE_BUTTON_UPDATE has been sent. "
"mode = %d\n", fCanna->GetMode()));
}
if ((result & GUIDELINE_CHANGED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_CHANGED\n"));
fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
}
if ((result & THROUGH_INPUT) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"THROUGH_INPUT\n"));
EnqueueMessage(DetachCurrentMessage());
}
if ((result & NEW_INPUT_STARTED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"NEW_INPUT_STARTED\n"));
SendInputStarted();
}
if ((result & KAKUTEI_EXISTS) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"KAKUTEI_EXISTS\n"));
BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
msg->AddString("be:string", fCanna->GetKakuteiStr());
msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", fCanna->KakuteiLength());
msg->AddInt32("be:selection", fCanna->KakuteiLength());
msg->AddInt32("be:selection", fCanna->KakuteiLength());
msg->AddBool("be:confirmed", true);
fOwner->EnqueueMessage(msg);
SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_CHANGED (confired) has "
"been sent\n"));
// if both kakutei and mikakutei exist, do not send B_INPUT_STOPPED
if (!(result & MIKAKUTEI_EXISTS))
SendInputStopped();
}
if ((result & MIKAKUTEI_EXISTS) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"MIKAKUTEI_EXISTS\n" ));
int32 start, finish;
BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
msg->AddString("be:string", fCanna->GetMikakuteiStr());
if (fCanna->HasRev()) {
fCanna->GetRevPosition( &start, &finish);
msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", start);
msg->AddInt32("be:clause_start", start);
msg->AddInt32("be:clause_end", finish);
msg->AddInt32("be:clause_start", finish);
msg->AddInt32("be:clause_end", fCanna->MikakuteiLength());
} else {
start = finish = fCanna->MikakuteiLength();
msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", fCanna->MikakuteiLength());
}
msg->AddInt32("be:selection", start);
msg->AddInt32("be:selection", finish);
//msg->AddBool("be:confirmed", false);
fOwner->EnqueueMessage(msg);
SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_CHANGED (non-confirmed) "
"has been sent\n"));
}
if ((result & MIKAKUTEI_BECOME_EMPTY) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"MIKAKUTEI_BECOME_EMPTY\n" ));
BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
msg->AddString("be:string", B_EMPTY_STRING);
msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", 0);
msg->AddInt32("be:selection", 0);
msg->AddInt32("be:selection", 0);
msg->AddBool( "be:confirmed", true);
fOwner->EnqueueMessage(msg);
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_CHANGED (NULL, confired) "
"has been sent\n"));
SendInputStopped();
}
}
void
BrowserApp::MessageReceived(BMessage* message)
{
switch (message->what) {
case PRELOAD_BROWSING_HISTORY:
// Accessing the default instance will load the history from disk.
BrowsingHistory::DefaultInstance();
break;
case B_SILENT_RELAUNCH:
_CreateNewPage("");
break;
case NEW_WINDOW: {
BString url;
if (message->FindString("url", &url) != B_OK)
break;
_CreateNewWindow(url);
break;
}
case NEW_TAB: {
BrowserWindow* window;
if (message->FindPointer("window",
reinterpret_cast<void**>(&window)) != B_OK)
break;
BString url;
message->FindString("url", &url);
bool select = false;
message->FindBool("select", &select);
_CreateNewTab(window, url, select);
break;
}
case WINDOW_OPENED:
fWindowCount++;
fDownloadWindow->SetMinimizeOnClose(false);
break;
case WINDOW_CLOSED:
fWindowCount--;
message->FindRect("window frame", &fLastWindowFrame);
if (fWindowCount <= 0) {
BMessage* message = new BMessage(B_QUIT_REQUESTED);
message->AddMessage("window", DetachCurrentMessage());
PostMessage(message);
}
break;
case SHOW_DOWNLOAD_WINDOW:
_ShowWindow(message, fDownloadWindow);
break;
case SHOW_SETTINGS_WINDOW:
_ShowWindow(message, fSettingsWindow);
break;
case SHOW_CONSOLE_WINDOW:
_ShowWindow(message, fConsoleWindow);
break;
case SHOW_COOKIE_WINDOW:
_ShowWindow(message, fCookieWindow);
break;
case ADD_CONSOLE_MESSAGE:
fConsoleWindow->PostMessage(message);
break;
default:
BApplication::MessageReceived(message);
break;
}
}
void
MediaConverterWindow::MessageReceived(BMessage* message)
{
entry_ref inRef;
char buffer[40];
BEntry inEntry;
switch (message->what) {
#if B_BEOS_VERSION <= B_BEOS_VERSION_6
case B_LANGUAGE_CHANGED:
LanguageChanged();
break;
#endif
case INIT_FORMAT_MENUS:
BuildFormatMenu();
if (CountSourceFiles() == 0)
SetEnabled(false, false);
break;
case B_SIMPLE_DATA:
if (message->WasDropped()) {
DetachCurrentMessage();
message->what = B_REFS_RECEIVED;
BMessenger(be_app).SendMessage(message);
delete message;
}
break;
case FORMAT_SELECT_MESSAGE:
BuildAudioVideoMenus();
break;
case AUDIO_CODEC_SELECT_MESSAGE:
break;
case VIDEO_CODEC_SELECT_MESSAGE:
break;
case CONVERT_BUTTON_MESSAGE:
if (!fConverting) {
fConvertButton->SetLabel(B_TRANSLATE("Cancel"));
fConverting = true;
SetStatusMessage(B_TRANSLATE("Convert"));
SetEnabled(false, true);
BMessenger(be_app).SendMessage(START_CONVERSION_MESSAGE);
} else if (!fCancelling) {
fCancelling = true;
SetStatusMessage(B_TRANSLATE("Cancelling" B_UTF8_ELLIPSIS));
BMessenger(be_app).SendMessage(CANCEL_CONVERSION_MESSAGE);
}
break;
case CONVERSION_DONE_MESSAGE:
{
SetStatusMessage(fCancelling ? B_TRANSLATE("Conversion cancelled")
: B_TRANSLATE("Conversion completed"));
fConverting = false;
fCancelling = false;
bool enable = CountSourceFiles() > 0;
SetEnabled(enable, enable);
fConvertButton->SetLabel(B_TRANSLATE("Convert"));
break;
}
case OUTPUT_FOLDER_MESSAGE:
// Execute Save Panel
if (fSaveFilePanel == NULL) {
BButton* selectThisDir;
BMessage folderSelect(FOLDER_SELECT_MESSAGE);
fSaveFilePanel = new BFilePanel(B_OPEN_PANEL, NULL, NULL,
B_DIRECTORY_NODE, true, &folderSelect, NULL, false, true);
fSaveFilePanel->SetButtonLabel(B_DEFAULT_BUTTON,
B_TRANSLATE("Select"));
fSaveFilePanel->SetTarget(this);
fSaveFilePanel->Window()->Lock();
fSaveFilePanel->Window()->SetTitle(
B_TRANSLATE("MediaConverter+:SaveDirectory"));
BRect buttonRect
= fSaveFilePanel->Window()->ChildAt(0)->FindView(
"cancel button")->Frame();
buttonRect.right = buttonRect.left - 20;
buttonRect.left = buttonRect.right - 130;
selectThisDir = new BButton(buttonRect, NULL,
B_TRANSLATE("Select this folder"),
new BMessage(SELECT_THIS_DIR_MESSAGE),
B_FOLLOW_BOTTOM | B_FOLLOW_RIGHT);
selectThisDir->SetTarget(this);
fSaveFilePanel->Window()->ChildAt(0)->AddChild(selectThisDir);
fSaveFilePanel->Window()->Unlock();
fSaveFilePanel->SetRefFilter(new DirectoryFilter);
}
fSaveFilePanel->Show();
break;
case FOLDER_SELECT_MESSAGE:
// "SELECT" Button at Save Panel Pushed
fSaveFilePanel->GetNextSelectedRef(&inRef);
inEntry.SetTo(&inRef, true);
_SetOutputFolder(inEntry);
fOutputDirSpecified = true;
fSaveFilePanel->Rewind();
break;
case SELECT_THIS_DIR_MESSAGE:
// "THIS DIR" Button at Save Panel Pushed
fSaveFilePanel->GetPanelDirectory(&inRef);
fSaveFilePanel->Hide();
inEntry.SetTo(&inRef, true);
_SetOutputFolder(inEntry);
fOutputDirSpecified = true;
break;
case OPEN_FILE_MESSAGE:
// Execute Open Panel
if (!fOpenFilePanel) {
fOpenFilePanel = new BFilePanel(B_OPEN_PANEL, NULL, NULL,
B_FILE_NODE, true, NULL, NULL, false, true);
fOpenFilePanel->SetTarget(this);
}
fOpenFilePanel->Show();
break;
case B_REFS_RECEIVED:
// Media Files Seleced by Open Panel
DetachCurrentMessage();
message->what = B_REFS_RECEIVED;
BMessenger(be_app).SendMessage(message);
// fall through
case B_CANCEL:
break;
case QUIT_MESSAGE:
MediaConverterWindow::QuitRequested();
break;
case PREVIEW_MESSAGE:
{
// Build the command line to launch the preview application.
// TODO: Launch the default app instead of hardcoded MediaPlayer!
int32 srcIndex = fListView->CurrentSelection();
BMediaFile* inFile = NULL;
status_t status = GetSourceFileAt(srcIndex, &inFile, &inRef);
const char* argv[3];
BString startPosString;
BPath path;
if (status == B_OK) {
argv[0] = "-pos";
// NOTE: -pos argument is currently not supported by Haiku
// MediaPlayer.
startPosString << fStartDurationTC->Text();
startPosString << "000";
argv[1] = startPosString.String();
status = inEntry.SetTo(&inRef);
}
if (status == B_OK) {
status = inEntry.GetPath(&path);
if (status == B_OK)
argv[2] = path.Path();
}
if (status == B_OK) {
status = be_roster->Launch(
"application/x-vnd.Haiku-MediaPlayer",
3, (char**)argv, NULL);
}
if (status != B_OK && status != B_ALREADY_RUNNING) {
BString errorString(B_TRANSLATE("Error launching: %strError%"));
errorString.ReplaceFirst("%strError%", strerror(status));
BAlert* alert = new BAlert(B_TRANSLATE("Error"),
errorString.String(), B_TRANSLATE("OK"));
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
break;
}
case VIDEO_QUALITY_CHANGED_MESSAGE:
{
int32 value;
message->FindInt32("be:value", &value);
snprintf(buffer, sizeof(buffer),
B_TRANSLATE("Video quality: %3d%%"), (int8)value);
fVideoQualitySlider->SetLabel(buffer);
fVideoQuality = value;
break;
}
case AUDIO_QUALITY_CHANGED_MESSAGE:
{
int32 value;
message->FindInt32("be:value", &value);
snprintf(buffer, sizeof(buffer),
B_TRANSLATE("Audio quality: %3d%%"), (int8)value);
fAudioQualitySlider->SetLabel(buffer);
fAudioQuality = value;
break;
}
default:
BWindow::MessageReceived(message);
}
}
