void RDDBIcon::MessageReceived(BMessage *msg)
{
switch(msg->what)
{
case RESTART_RD:
{
status_t error=B_NO_ERROR;
BMessenger msgr(APP1SIG,-1,&error);
BMessage reply;
BMessage rmsg(RD_RESTART_RD);
msgr.SendMessage(&rmsg,&reply,200000,300000);
if ((reply.what!=B_OK) || (error!=B_OK))
(new BAlert("RD","There has been a problem restarting the restart_daemon. Ironic, yes?","Drat!"))->Go(NULL);
}break;
case QUIT_RD:
{
status_t error=B_NO_ERROR;
BMessenger msgr(APP1SIG,-1,&error);
BMessage reply;
BMessage rmsg(RD_SHUTDOWN_RD);
msgr.SendMessage(&rmsg,&reply,200000,300000);
if ((reply.what!=B_OK) || (error!=B_OK))
(new BAlert("RD","There has been a problem shutting down the restart_daemon. Ironic, yes?","Drat!"))->Go(NULL);
}break;
default:
BView::MessageReceived(msg);
}
}
void CDoc::PostToAll(unsigned long msg, bool async)
{
doclist::iterator di;
doclist lst = sfDocList;
BLooper *me = BLooper::LooperForThread(find_thread(NULL));
for (di = lst.begin(); di != lst.end(); di++)
{
BWindow *w = dynamic_cast<BWindow*>(*di);
if (w)
{
BMessage reply;
if (async || w == dynamic_cast<BWindow*>(me))
w->PostMessage(msg);
else
{
BMessenger msgr(w);
FailOSErr(msgr.SendMessage(msg, &reply));
}
}
}
}
filter_result ProtocolFilter::Filter(BMessage *message, BHandler **target)
{
filter_result result;
switch (message->what)
{
//send these messages through to the NSLooper
case InterfaceMessages::K_USER_SIGN_IN_MSG:
case InterfaceMessages::K_USER_SIGN_OUT_MSG:
case InterfaceMessages::K_USER_CHANGE_STATUS_MSG:
case InterfaceMessages::K_USER_CHANGE_NAME_MSG:
case InterfaceMessages::K_USER_SET_PERSONAL_MSG:
case InterfaceMessages::K_USER_ADD_GROUP_MSG:
case InterfaceMessages::K_USER_REMOVE_GROUP_MSG:
case InterfaceMessages::K_USER_RENAME_GROUP_MSG:
case InterfaceMessages::K_USER_START_CONV_MSG:
{
BMessenger msgr(m_nsLooper);
msgr.SendMessage(message);
result = B_SKIP_MESSAGE;
}
break;
//send through to default handler
case InterfaceMessages::K_CONTACT_REQUEST_ADD_MSG:
case InterfaceMessages::K_GET_LOGIN_NAMES:
{
result = B_DISPATCH_MESSAGE;
}
break;
default:
result = B_SKIP_MESSAGE;
break;
}
return result;
}
void TexView::KeyDown(const char* bytes, int32 numBytes)
{
switch(bytes[0])
{
case B_ENTER:
{
//update previous line on enter
BMessage msg(InterfaceConstants::K_PARSE_LINE);
int32 start,finish;
GetSelection(&start,&finish);
if(msg.AddInt32("start",start) == B_OK
&& msg.AddInt32("finish",finish) == B_OK)
Window()->PostMessage(&msg,this);
}
break;
case B_TAB:
{
if(IsNormalFocus)
{
Parent()->NextSibling()->MakeFocus();
return;
}
}
break;
}
BTextView::KeyDown(bytes,numBytes);
BMessenger msgr(Window());
msgr.SendMessage(new BMessage(InterfaceConstants::K_UPDATE_STATUSBAR));
}
status_t
WinampSkinThemesAddon::CLSkin(BString *to, bool preffile)
{
if (preffile) {
BPath CLSPath;
char buffer[B_FILE_NAME_LENGTH+1];
if (!to)
return EINVAL;
buffer[B_FILE_NAME_LENGTH] = '\0';
if (find_directory(B_USER_SETTINGS_DIRECTORY, &CLSPath) < B_OK)
return B_ERROR;
CLSPath.Append(CL_SETTINGS_NAME);
BFile CLSettings(CLSPath.Path(), B_READ_ONLY);
if (CLSettings.InitCheck() < B_OK)
return CLSettings.InitCheck();
ssize_t got = CLSettings.ReadAt(0x8LL, buffer, B_FILE_NAME_LENGTH);
if (got < B_FILE_NAME_LENGTH)
return EIO;
*to = buffer;
StripPath(to);
return B_ERROR;
}
BMessenger msgr(CL_APP_SIG);
BMessage msg('skin');
BMessage reply;
msgr.SendMessage(&msg, &reply, 500000, 500000);
if (reply.FindString("result", to) >= B_OK) {
StripPath(to);
return B_OK;
}
return B_ERROR;
}
status_t
WinampSkinThemesAddon::SPSkin(BString *to, bool preffile)
{
if (preffile) {
status_t err;
BMessage settings;
BPath SPSPath;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &SPSPath) < B_OK)
return B_ERROR;
BString leaf(SP_SETTINGS_NAME);
BString user(getenv("USER"));
user.RemoveFirst("USER="******"$USER", user.String());
SPSPath.Append(leaf.String());
PRINT(("SPP %s\n", SPSPath.Path()));
BFile SPSettings(SPSPath.Path(), B_READ_ONLY);
if (SPSettings.InitCheck() < B_OK)
return SPSettings.InitCheck();
if (settings.Unflatten(&SPSettings) < B_OK)
return EIO;
err = settings.FindString("skinname", to);
StripPath(to);
return err;
}
BMessenger msgr(SP_APP_SIG);
BMessage msg('skin');
BMessage reply;
msgr.SendMessage(&msg, (BHandler *)NULL, 500000);
if (reply.FindString("result", to) >= B_OK) {
StripPath(to);
return B_OK;
}
return B_ERROR;
}
status_t
WinampSkinThemesAddon::SetCLSkin(BString *from)
{
status_t err;
BPath p;
err = CLSkinPath(&p);
if (err < B_OK)
return err;
p.Append(from->String());
/* update the prefs file */
BPath CLSPath;
if (!from)
return EINVAL;
/* CL-Amp doesn't grok long names */
if (strlen(p.Path()) >= B_FILE_NAME_LENGTH)
return B_NAME_TOO_LONG;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &CLSPath) < B_OK)
return B_ERROR;
CLSPath.Append(CL_SETTINGS_NAME);
BFile CLSettings(CLSPath.Path(), B_WRITE_ONLY);
if (CLSettings.InitCheck() < B_OK)
return CLSettings.InitCheck();
CLSettings.WriteAt(0x8LL, p.Path(), strlen(p.Path())+1);
/* then tell the app */
BMessenger msgr(CL_APP_SIG);
BMessage msg('skin');
msg.AddString("name", p.Path());
msg.PrintToStream();
msgr.SendMessage(&msg, (BHandler *)NULL, 500000);
return B_OK;
}
void
SButton::MouseDown(BPoint where)
{
if(!IsEnabled()) return;
BWindow *window = Window();
if(!(window->Flags() & B_AVOID_FOCUS)) window->Activate();
if(tooltips)
{
BMessage msg(S_TOOLTIPS_CHANGED);
msg.AddBool("state", false);
BMessenger msgr(NULL, window);
msgr.SendMessage(&msg);
}
if(!waitting_is_keyboard)
{
waitting = true;
DrawDefault(Bounds(), true, window->IsActive());
SetMouseEventMask(B_POINTER_EVENTS, B_SUSPEND_VIEW_FOCUS | B_LOCK_WINDOW_FOCUS);
window->UpdateIfNeeded();
}
}
void VisionApp::Broadcast(BMessage* msg)
{
for (int32 i = 0; i < CountWindows(); ++i) {
BMessenger msgr(WindowAt(i));
msgr.SendMessage(msg);
}
}
bool VisionApp::QuitRequested(void)
{
fShuttingDown = true;
if (fIdentSocket >= 0) close(fIdentSocket);
BMessenger msgr(fClientWin);
if (msgr.IsValid()) msgr.SendMessage(B_QUIT_REQUESTED);
if (fSetupWin) BMessenger(fSetupWin).SendMessage(B_QUIT_REQUESTED);
if (fPrefsWin) BMessenger(fPrefsWin).SendMessage(B_QUIT_REQUESTED);
if (fNetWin) BMessenger(fPrefsWin).SendMessage(B_QUIT_REQUESTED);
// give our child threads a chance to die gracefully
while (ThreadStates() > 2) snooze(100000);
if (fSettingsLoaded) {
SaveSettings();
delete fVisionSettings;
}
return true;
}
int32 FileDaemon::WaitOnRequests(void *arg) {
FileDaemon *us = reinterpret_cast<FileDaemon *>(arg);
status_t err = B_ERROR;
BMessenger msgr(us);
bool work = true;
thread_id thread = find_thread(NULL);
while (work) {
snooze(kSnoozeTime);
BMessage getRequest(kGetRequest);
getRequest.AddInt32("threadid", thread);
BMessage reply;
if (msgr.SendMessage(&getRequest, &reply) != B_OK) {
work = false;
continue;
};
RequestInfo *info = NULL;
reply.FindBool("continue", &work);
if (reply.FindPointer("requestinfo", reinterpret_cast<void **>(&info)) != B_OK) continue;
if (info == NULL) continue;
status_t result = info->request->Start();
// Send the complete/ error message
if (info->target) {
fprintf(stderr, "FileDaemon::WaitOnRequests(): %s: %s (%i)\n", info->request->URL(),
strerror(result), result);
switch (result) {
case B_OK: {
if (info->finish) info->target->SendMessage(info->finish);
} break;
case DownloadCancelled: {
if (info->cancel) info->target->SendMessage(info->cancel);
} break;
default: {
if (info->error) info->target->SendMessage(info->error);
} break;
};
};
BMessage requestComplete(kRequestComplete);
requestComplete.AddInt32("threadid", thread);
requestComplete.AddPointer("requestinfo", &info);
msgr.SendMessage(&requestComplete);
};
BMessage threadComplete(kThreadComplete);
threadComplete.AddInt32("threadid", thread);
msgr.SendMessage(&threadComplete);
return B_OK;
};
void SnowView::MouseUp(BPoint where)
{
#ifdef FORWARD_TO_PARENT
if (fAttached && Parent())
Parent()->MouseUp(where);
#endif
if (fCachedParent)
return; /* we are *inside* the Tracker,
* don't even try talking to ourselve
* with the window locked
*/
BMessenger msgr("application/x-vnd.Be-TRAK");
BMessage msg(B_DELETE_PROPERTY), reply;
msg.AddSpecifier("Replicant", "BSnow");
msg.AddSpecifier("Shelf");
msg.AddSpecifier("View", "PoseView");
msg.AddSpecifier("Window", 1); /* 0 is Tracker Status */
if ((msgr.SendMessage(&msg, &reply) == B_OK) &&
(reply.what == B_NO_REPLY || reply.what == B_REPLY)) {
//reply.PrintToStream();
fShowClickMe = false;
Invalidate(Bounds());
}
/*
BMessage: what = JAHA (0x4a414841, or 1245792321)
entry index, type='LONG', c=1, size= 4, data[0]: 0x2 (2, '')
entry when, type='LLNG', c=1, size= 8, data[0]: 0xf6a1b09ac (66204666284, '')
entry source, type='PNTR', c=1, size= 4,
entry be:sender, type='MSNG', c=1, size=24,
*/
}
void ClientAgentInputFilter::HandleDrop(const char* buffer)
{
BMessage msg(M_SUBMIT_INPUT);
const char* place;
int32 lines(0);
BMessenger msgr(fWindow);
while ((place = strchr(buffer, '\n'))) {
BString str;
str.Append(buffer, place - buffer);
msg.AddString("data", str.String());
++lines;
buffer = place + 1;
}
if (*buffer) {
msg.AddString("data", buffer);
++lines;
}
int32 start, finish;
fWindow->fInput->TextView()->GetSelection(&start, &finish);
msg.AddInt32("selstart", start);
msg.AddInt32("selend", finish);
if (lines > 1) {
if (true == vision_app->GetBool("Newbie Spam Mode")) {
BString str;
str += "As if there isn't enough, you ";
str += "are about to add ";
str << lines;
str += " more lines of spam to ";
str += "the internet. How ";
str += "would you like to go about this?";
BAlert* alert(new BAlert("Spam", str.String(), "Cancel", "Spam!", "Single line",
B_WIDTH_FROM_WIDEST, B_OFFSET_SPACING, B_WARNING_ALERT));
BMessage* invokeMsg(new BMessage(msg));
BInvoker* invoker(new BInvoker(invokeMsg, msgr));
invokeMsg->AddPointer("invoker", invoker);
alert->Go(invoker);
} else {
msg.AddInt32("which", PASTE_MULTI);
msgr.SendMessage(&msg);
}
}
if (lines == 1) {
msg.AddInt32("which", PASTE_SINGLE);
msgr.SendMessage(&msg);
fWindow->fInput->MakeFocus(false);
fWindow->fInput->MakeFocus(true);
}
}
void TexView::Select(int32 start,int32 finish)
{
BTextView::Select(start,finish);
if(!IsShifting)
{
BMessenger msgr(Window());
msgr.SendMessage(new BMessage(InterfaceConstants::K_UPDATE_STATUSBAR));
}
}
void
SButton::MouseMoved(BPoint pt, uint32 code, const BMessage *msg)
{
if(!IsEnabled()) return;
BWindow *window = Window();
uint32 btns;
GetMouse(&pt, &btns, false);
if(Bounds().Contains(pt) && code == B_ENTERED_VIEW)
{
if(!waitting && tooltips)
{
BMessage msg(S_TOOLTIPS_CHANGED);
msg.AddBool("state", true);
msg.AddString("tooltips", tooltips);
TooltipsLocation(&msg);
BMessenger msgr(NULL, window);
msgr.SendMessage(&msg);
}
else if(waitting && !waitting_is_keyboard)
{
DrawDefault(Bounds(), true, true);
window->UpdateIfNeeded();
}
}
else if(code == B_EXITED_VIEW)
{
if(!Bounds().Contains(pt) && tooltips)
{
BMessage msg(S_TOOLTIPS_CHANGED);
msg.AddBool("state", false);
BMessenger msgr(NULL, window);
msgr.SendMessage(&msg);
}
if(waitting && !waitting_is_keyboard)
{
DrawDefault(Bounds(), false, true);
window->UpdateIfNeeded();
}
}
}
void CurView::AllAttached(void)
{
attrlist->Select(0);
attrlist->SetTarget(this);
apply->SetTarget(this);
defaults->SetTarget(this);
revert->SetTarget(this);
bmpview->SetTarget(this);
BMessenger msgr(this);
}
/** Hook function: handles received messages.
@param message, the current message from the message queue to handle
*/
void BmeApp::MessageReceived(BMessage* message)
{
switch(message->what)
{
//if soundplay or CL-amp wants to set current track playing
case InterfaceMessages::K_USER_SET_PERSONAL_MSG:
{
BMessenger msgr(m_protocolLooper);
msgr.SendMessage(message);
}
break;
case InterfaceMessages::K_PREFERENCES_MSG:
{
BRect prefsFrame(100.0f,100.0f,650.0f,420.0f);
PrefsWindow *prefsWindow = new PrefsWindow(prefsFrame,"Bme Preferences", B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, 0);
BString activeTab;
if (message->FindString(K_ACTIVE_TAB, &activeTab) == B_OK)
{
//if available, make the tab passed in this message the active one
prefsWindow->SetActiveTab(activeTab);
}
//show the preference window
prefsWindow->Show();
}
break;
default:
{
int32 noHandlers = CountHandlers();
if (noHandlers > 1)
{
//make sure the message won't be send to the looper main handler again!
for (int32 i = 1; i < noHandlers; i++)
{
BHandler *handler = HandlerAt(i);
BMessenger msgr(handler);
msgr.SendMessage(message);
}
}
}
break;
}
}
bool PaletteWindow::QuitRequested(void)
{
status_t status;
BMessenger msgr(target);
status = msgr.SendMessage(M_PALETTE_QUIT);
if (status != B_OK) {
_sPrintf("Error sendging M_CONFIG_QUIT: %s\n", strerror(status));
}
return true;
}
BHandler * ResolveSpecifier(BMessage *msg, int32 index, BMessage *spec, int32 form, const char *prop) {
BPropertyInfo prop_info(main_prop_list);
printf("app: looking for property %s\n",prop);
if (strcmp(prop, "message") == 0) {
BMessenger msgr(fWin);
msgr.SendMessage(msg,fWin);
return NULL;
};
return BApplication::ResolveSpecifier(msg, index, spec, form, prop);
};
void
PatchView::AttachedToWindow()
{
BMidiRoster* roster = BMidiRoster::MidiRoster();
if (roster == NULL) {
PRINT(("Couldn't get MIDI roster\n"));
be_app->PostMessage(B_QUIT_REQUESTED);
return;
}
BMessenger msgr(this);
roster->StartWatching(&msgr);
}
void
IncludeList::RefDropped(entry_ref ref)
{
RefListItem *item = new RefListItem(ref,REFITEM_OTHER);
BString text(BPath(&ref).Path());
text.RemoveFirst(fProjectPath);
AddItem(item);
item->SetText(text.String());
BMessenger msgr(Parent());
BMessage msg(M_DROP_PATH);
msg.AddString("path",text);
msgr.SendMessage(&msg);
}
void
App::CheckCreateOpenPanel()
{
if (NULL == fOpenPanel)
{
BMessenger msgr(this);
BEntry entry(gLastProjectPath.GetFullPath());
entry_ref ref;
entry.GetRef(&ref);
fOpenPanel = new BFilePanel(B_OPEN_PANEL, &msgr, &ref, B_FILE_NODE, false,
new BMessage(B_REFS_RECEIVED), new PaladinFileFilter() );
fOpenPanel->Window()->SetTitle(B_TRANSLATE("Paladin: Open project"));
}
}
// ---------------------------------------------------------------
// AllAttached
//
//
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
void
SlideShowConfigView::AllAttached()
{
BMessenger msgr(this);
fShowCaption->SetTarget(msgr);
fShowBorder->SetTarget(msgr);
fChooseFolder->SetTarget(msgr);
fFilePanel->SetTarget(msgr);
// Set target for menu items
for (int32 i = 0; i < fDelayMenu->CountItems(); i++) {
BMenuItem *item = fDelayMenu->ItemAt(i);
if (item)
item->SetTarget(msgr);
}
}
bool FastTraxWindow::QuitRequested( void )
{
// Response to Close Message, not to Application Quiting
if( CurrentMessage() )
{
BMessenger msgr( be_app ) ;
BMessage reply ;
if( msgr.IsValid() )
{
BMessage msg( Messages::WindowClosed ) ;
msg.AddPointer( "Window", this ) ;
msgr.SendMessage( &msg , &reply ) ;
}
}
return inherited :: QuitRequested( ) ;
}
void SnowView::Pulse()
{
if (fShowClickMe)
return; /* done */
if (fCachedParent)
return; /* we are in Tracker! */
BMessenger msgr("application/x-vnd.Be-TRAK");
BMessage msg(B_GET_PROPERTY), reply;
msg.AddSpecifier("Frame");
msg.AddSpecifier("View", "BSnow");
msg.AddSpecifier("Window", 1); /* 0 is Twitcher */
if (msgr.SendMessage(&msg, &reply) == B_OK && reply.what == B_REPLY) {
//reply.PrintToStream();
Invalidate(Bounds());
fShowClickMe = true;
}
}
void
PrintersApp::MessageReceived(BMessage* msg)
{
if (msg->what == B_PRINTER_CHANGED || msg->what == PRINTERS_ADD_PRINTER) {
// broadcast message
uint32 what = msg->what;
if (what == PRINTERS_ADD_PRINTER)
what = kMsgAddPrinter;
BWindow* w;
for (int32 i = 0; (w = WindowAt(i)) != NULL; i++) {
BMessenger msgr(NULL, w);
msgr.SendMessage(what);
}
} else {
BApplication::MessageReceived(msg);
}
}
void AgentDockHeaderString::MouseUp(BPoint where)
{
SetViewColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR), B_DARKEN_1_TINT));
Parent()->SetViewColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR), B_DARKEN_1_TINT));
Invalidate();
Parent()->Invalidate();
// check if this header string belongs to notify list and send resize message if so
BView* notifyList(Parent());
if (notifyList && dynamic_cast<AgentDockHeader*>(notifyList) != NULL) {
notifyList = notifyList->Parent();
if (notifyList && dynamic_cast<AgentDockNotifyList*>(notifyList) != NULL) {
BMessenger msgr(((AgentDockNotifyList*)notifyList)->pNotifyList());
if (msgr.IsValid()) msgr.SendMessage(M_NOTIFYLIST_RESIZE);
}
}
BStringView::MouseUp(where);
}
status_t
SoundplayThemesAddon::ApplyTheme(BMessage &theme, uint32 flags)
{
BMessage uisettings;
status_t err;
rgb_color panelcol;
int32 wincnt = 1;
err = theme.FindMessage(Z_THEME_UI_SETTINGS, &uisettings);
if (err)
return err;
if (FindRGBColor(uisettings, B_UI_PANEL_BACKGROUND_COLOR, 0, &panelcol) < B_OK)
panelcol = make_color(216,216,216,255);
if (flags & UI_THEME_SETTINGS_SAVE && AddonFlags() & Z_THEME_ADDON_DO_SAVE) {
// WRITEME
}
if (flags & UI_THEME_SETTINGS_APPLY && AddonFlags() & Z_THEME_ADDON_DO_APPLY) {
BMessenger msgr(kSoundPlaySig);
BMessage command(B_COUNT_PROPERTIES);
BMessage answer;
command.AddSpecifier("Window");
err = msgr.SendMessage(&command, &answer,2000000LL,2000000LL);
if(B_OK == err) {
if (answer.FindInt32("result", &wincnt) != B_OK)
wincnt = 1;
}
BMessage msg(B_PASTE);
AddRGBColor(msg, "RGBColor", panelcol);
msg.AddPoint("_drop_point_", BPoint(0,0));
// send to every window (the Playlist window needs it too)
for (int32 i = 0; i < wincnt; i++) {
BMessage wmsg(msg);
wmsg.AddSpecifier("Window", i);
msgr.SendMessage(&wmsg, (BHandler *)NULL, 2000000LL);
}
}
return B_OK;
}
App::App(void)
: BApplication(APP_SIGNATURE),
fBuildCleanMode(false),
fBuilder(NULL)
{
InitFileTypes();
InitGlobals();
EnsureTemplates();
gProjectList = new LockableList<Project>(20,true);
gProjectWindowPoint.Set(5,24);
BMessenger msgr(this);
BEntry entry(gLastProjectPath.GetFullPath());
entry_ref ref;
entry.GetRef(&ref);
fOpenPanel = new BFilePanel(B_OPEN_PANEL,&msgr,&ref,B_FILE_NODE,true,
new BMessage(B_REFS_RECEIVED));
fOpenPanel->Window()->SetTitle("Paladin: Open Project");
}
status_t
TerminalThemesAddon::RunPreferencesPanel()
{
status_t err;
// make sure Terminal is running
if (!be_roster->IsRunning(kHaikuTerminalAppSig)) {
err = be_roster->Launch(kHaikuTerminalAppSig);
if (err < B_OK)
return err;
}
// and fake the menu item click
BMessage command('MPre');
command.AddSpecifier("Window", (int32)0);
BMessenger msgr(kHaikuTerminalAppSig);
err = msgr.SendMessage(&command);
return err;
}
