status_t
Icon::CopyTo(BMessage& message) const
{
status_t status = B_OK;
if (status == B_OK && fLarge != NULL) {
BMessage archive;
status = fLarge->Archive(&archive);
if (status == B_OK)
status = message.AddMessage("icon/large", &archive);
}
if (status == B_OK && fMini != NULL) {
BMessage archive;
status = fMini->Archive(&archive);
if (status == B_OK)
status = message.AddMessage("icon/mini", &archive);
}
if (status == B_OK && fData != NULL)
status = message.AddData("icon", B_VECTOR_ICON_TYPE, fData, fSize);
return B_OK;
}
status_t
BreakpointListView::SaveSettings(BMessage& settings)
{
settings.MakeEmpty();
BMessage tableSettings;
status_t result = GUISettingsUtils::ArchiveTableSettings(tableSettings,
fBreakpointsTable);
if (result == B_OK)
result = settings.AddMessage("breakpointsTable", &tableSettings);
return result;
}
status_t
StackTraceView::SaveSettings(BMessage& settings)
{
settings.MakeEmpty();
BMessage tableSettings;
status_t result = GuiSettingsUtils::ArchiveTableSettings(tableSettings,
fFramesTable);
if (result == B_OK)
result = settings.AddMessage("framesTable", &tableSettings);
return result;
}
status_t
ImageFunctionsView::SaveSettings(BMessage& settings)
{
settings.MakeEmpty();
BMessage tableSettings;
status_t result = GUISettingsUtils::ArchiveTableSettings(tableSettings,
fFunctionsTable);
if (result == B_OK)
result = settings.AddMessage("functionsTable", &tableSettings);
return result;
}
void
MainWindow::StoreSettings(BMessage& settings) const
{
settings.AddRect("window frame", Frame());
BMessage columnSettings;
fPackageListView->SaveState(&columnSettings);
settings.AddMessage("column settings", &columnSettings);
settings.AddBool("show develop packages", fModel.ShowDevelopPackages());
settings.AddBool("show source packages", fModel.ShowSourcePackages());
}
status_t
PeThemesAddon::ApplyDefaultTheme(uint32 flags)
{
BMessage theme;
BMessage uisettings;
rgb_color bg = {255, 255, 255, 255};
rgb_color fg = {0, 0, 0, 255};
rgb_color selbg = {180, 200, 240, 255};
AddRGBColor(uisettings, B_UI_DOCUMENT_BACKGROUND_COLOR, bg);
AddRGBColor(uisettings, B_UI_DOCUMENT_TEXT_COLOR, fg);
AddRGBColor(uisettings, B_UI_DOCUMENT_SELECTION_BACKGROUND_COLOR, selbg);
theme.AddMessage(Z_THEME_UI_SETTINGS, &uisettings);
return ApplyTheme(theme, flags);
}
bool
MailAddonSettings::Save(BMessage& message)
{
if (!AddonSettings::Save(message))
return false;
for (int i = 0; i < CountFilterSettings(); i++) {
BMessage filter;
AddonSettings& filterSettings = fFiltersSettings[i];
filterSettings.Save(filter);
message.AddMessage("filters", &filter);
}
return true;
}
void
Settings::Save(BFile* file)
{
BMessage message;
// store application settings
for (int i = 0; i < AppSettingsCount(); i++) {
AppSettings* app = AppSettingsAt(i);
message.AddString("message", app->GetMimeType());
message.AddString("p", app->GetPrinter());
}
// store printer settings
for (int i = 0; i < PrinterSettingsCount(); i++) {
PrinterSettings* p = PrinterSettingsAt(i);
message.AddString("P", p->GetPrinter());
message.AddMessage("S", p->GetPageSettings());
message.AddMessage("J", p->GetJobSettings());
}
message.AddBool("UseConfigWindow", fUseConfigWindow);
message.AddRect("ConfigWindowFrame", fConfigWindowFrame);
message.AddString("DefaultPrinter", fDefaultPrinter);
message.Flatten(file);
}
status_t
ThemesAddon::SetMyMessage(BMessage &theme, BMessage &mine)
{
FENTRY;
status_t err;
BMessage msg;
if (!MessageName())
return B_NAME_NOT_FOUND;
err = theme.FindMessage(MessageName(), &msg);
if (err)
err = theme.AddMessage(MessageName(), &mine);
else
err = theme.ReplaceMessage(MessageName(), &mine);
return err;
}
BMessage* ShortCutFilter::GetShortcutList(void)
{
map<uint32, shortcut*>::iterator iter;
shortcut *theShortcut = NULL;
BMessage *returnMessage = new BMessage();
for (iter =shortcutMap.begin();iter != shortcutMap.end();iter++)
{
theShortcut = iter->second;
returnMessage->AddInt32("key",theShortcut->key);
returnMessage->AddInt32("modifiers",theShortcut->modifiers);
returnMessage->AddMessage("message",theShortcut->sendMessage);
returnMessage->AddPointer("handler",theShortcut->sentTo);
}
return returnMessage;
}
void
Utility::CopyToClipboard(const BBitmap& screenshot) const
{
if (be_clipboard->Lock()) {
be_clipboard->Clear();
BMessage* clipboard = be_clipboard->Data();
if (clipboard) {
BMessage* bitmap = new BMessage();
screenshot.Archive(bitmap);
clipboard->AddMessage("image/bitmap", bitmap);
be_clipboard->Commit();
}
be_clipboard->Unlock();
}
}
status_t
TerminalThemesAddon::ApplyDefaultTheme(uint32 flags)
{
BMessage theme;
BMessage termpref;
// XXX: add font and stuff...
AddRGBColor(termpref, "term:c:bg",make_color(255,255,255,0));
AddRGBColor(termpref, "term:c:fg",make_color(0,0,0,0));
AddRGBColor(termpref, "term:c:curbg",make_color(0,0,0,0));
AddRGBColor(termpref, "term:c:curfg",make_color(255,255,255,0));
AddRGBColor(termpref, "term:c:selbg",make_color(0,0,0,0));
AddRGBColor(termpref, "term:c:selfg",make_color(255,255,255,0));
theme.AddMessage(Z_THEME_TERMINAL_SETTINGS, &termpref);
return ApplyTheme(theme, flags);
}
status_t
GUITeamUISettings::WriteTo(BMessage& archive) const
{
archive.MakeEmpty();
status_t error = archive.AddString("ID", fID);
if (error != B_OK)
return error;
error = archive.AddInt32("type", Type());
if (error != B_OK)
return error;
error = archive.AddMessage("values", &fValues);
return error;
}
void
NetServer::_BringUpInterfaces()
{
// we need a socket to talk to the networking stack
int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
if (socket < 0) {
fprintf(stderr, "%s: The networking stack doesn't seem to be "
"available.\n", Name());
Quit();
return;
}
_RemoveInvalidInterfaces(socket);
// First, we look into the settings, and try to bring everything up from there
BMessage missingDevice;
_ConfigureInterfaces(socket, &missingDevice);
// check configuration
if (!_TestForInterface(socket, "loop")) {
// there is no loopback interface, create one
BMessage interface;
interface.AddString("device", "loop");
BMessage address;
address.AddString("family", "inet");
address.AddString("address", "127.0.0.1");
interface.AddMessage("address", &address);
_ConfigureInterface(socket, interface);
}
// TODO: also check if the networking driver is correctly initialized!
// (and check for other devices to take over its configuration)
if (!_TestForInterface(socket, "/dev/net/")) {
// there is no driver configured - see if there is one and try to use it
_ConfigureDevices(socket, "/dev/net",
missingDevice.HasString("device") ? &missingDevice : NULL);
}
close(socket);
}
void
DownloadWindow::_SaveSettings()
{
BFile file;
if (!_OpenSettingsFile(file, B_ERASE_FILE | B_CREATE_FILE | B_WRITE_ONLY))
return;
BMessage message;
for (int32 i = fDownloadViewsLayout->CountItems() - 1;
BLayoutItem* item = fDownloadViewsLayout->ItemAt(i); i--) {
DownloadProgressView* view = dynamic_cast<DownloadProgressView*>(
item->View());
if (!view)
continue;
BMessage downloadArchive;
if (view->SaveSettings(&downloadArchive) == B_OK)
message.AddMessage("download", &downloadArchive);
}
message.Flatten(&file);
}
status_t
ScreensaverThemesAddon::ApplyTheme(BMessage &theme, uint32 flags)
{
BMessage screensaver;
status_t err;
BPath path;
BString str;
BMessage settings;
BMessage modsettings;
if (!(flags & UI_THEME_SETTINGS_SET_ALL) || !(AddonFlags() & Z_THEME_ADDON_DO_SET_ALL))
return B_OK;
err = MyMessage(theme, screensaver);
if (err)
return err;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) < B_OK)
return B_ERROR;
path.Append("ScreenSaver_settings");
BFile f(path.Path(), B_READ_WRITE);
if (settings.Unflatten(&f) < B_OK)
return B_ERROR;
if (screensaver.FindString(Z_THEME_SS_MODULE, &str) >= B_OK) {
if (settings.ReplaceString("modulename", str.String()) < B_OK)
if (settings.AddString("modulename", str.String()) < B_OK)
return B_ERROR;
if (screensaver.FindMessage(Z_THEME_SS_MODULE_SETTINGS, &modsettings) >= B_OK) {
BString msname(MS_NAME);
msname += str.String();
if (settings.ReplaceMessage(msname.String(), &modsettings) < B_OK)
settings.AddMessage(msname.String(), &modsettings);
}
f.Seek(0LL, SEEK_SET);
if (settings.Flatten(&f) < B_OK)
return B_ERROR;
}
return err;
}
status_t
TerminalThemesAddon::ApplyDefaultTheme(uint32 flags)
{
BMessage theme;
BMessage termpref;
int32 i;
// XXX: add font and stuff...
for (i = 0; i < NENTS(sHaikuPrefsMapInt32); i++) {
termpref.AddInt32(sHaikuPrefsMapInt32[i].name,
sHaikuPrefsMapInt32[i].def);
}
for (i = 0; i < NENTS(sHaikuPrefsMapColors); i++) {
AddRGBColor(termpref, sHaikuPrefsMapColors[i].name,
sHaikuPrefsMapColors[i].def);
}
theme.AddMessage(Z_THEME_TERMINAL_SETTINGS, &termpref);
return ApplyTheme(theme, flags);
}
status_t
SoundsThemesAddon::MakeTheme(BMessage &theme, uint32 flags)
{
BMessage sounds;
status_t err;
BMediaFiles bmfs;
BString item;
entry_ref entry;
BEntry ent;
BPath path;
float gain;
(void)flags;
err = MyMessage(theme, sounds);
if (err)
sounds.MakeEmpty();
bmfs.RewindRefs(BMediaFiles::B_SOUNDS);
while (bmfs.GetNextRef(&item, &entry) == B_OK) {
BMessage msg('SndI');
path.Unset();
ent.SetTo(&entry);
ent.GetPath(&path);
//printf("\t%s: %s\n", item.String(), path.Path());
if (path.Path()) {
msg.AddString("sounds:file", path.Path());
gain = 1.0;
#if defined(__ANTARES__) || defined(B_BEOS_VERSION_DANO)
bmfs.GetAudioGainFor(BMediaFiles::B_SOUNDS, item.String(), &gain);
#endif
msg.AddFloat("sounds:volume", gain);
}
sounds.AddMessage(item.String(), &msg);
}
err = SetMyMessage(theme, sounds);
return err;
}
void
BrowsingHistory::_SaveSettings()
{
BFile settingsFile;
if (_OpenSettingsFile(settingsFile,
B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY)) {
BMessage settingsArchive;
settingsArchive.AddInt32("max history item age", fMaxHistoryItemAge);
BMessage historyItemArchive;
int32 count = CountItems();
for (int32 i = 0; i < count; i++) {
BrowsingHistoryItem item = HistoryItemAt(i);
if (item.Archive(&historyItemArchive) != B_OK)
break;
if (settingsArchive.AddMessage("history item",
&historyItemArchive) != B_OK) {
break;
}
historyItemArchive.MakeEmpty();
}
settingsArchive.Flatten(&settingsFile);
}
}
status_t
UISettingsThemesAddon::ApplyDefaultTheme(uint32 flags)
{
BMessage theme;
BMessage uisettings;
BFont fnt;
status_t err;
err = get_default_settings(&uisettings);
if (err)
return err;
// hack for legacy fonts
err = BFont::GetStandardFont((font_which)(B_PLAIN_FONT-100), &fnt);
uisettings.AddFlat("be:f:be_plain_font", &fnt);
err = BFont::GetStandardFont((font_which)(B_BOLD_FONT-100), &fnt);
uisettings.AddFlat("be:f:be_bold_font", &fnt);
err = BFont::GetStandardFont((font_which)(B_FIXED_FONT-100), &fnt);
uisettings.AddFlat("be:f:be_fixed_font", &fnt);
theme.AddMessage(A_MSGNAME, &uisettings);
return ApplyTheme(theme, flags);
}
// _SaveSettings
status_t
NetFSServer::_SaveSettings()
{
AutoLocker<Locker> locker(fSecurityContext);
// create the settings archive
BMessage settings;
// archive the security context
BMessage securityContextArchive;
status_t error = fSecurityContext->Archive(&securityContextArchive, true);
if (error != B_OK)
RETURN_ERROR(error);
// add it to the settings archive
error = settings.AddMessage("security context", &securityContextArchive);
if (error != B_OK)
RETURN_ERROR(error);
// open the settings file
BPath filePath;
error = _GetSettingsFilePath(&filePath, true);
if (error != B_OK)
RETURN_ERROR(error);
BFile file;
error = FDManager::SetFile(&file, filePath.Path(),
B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
if (error != B_OK)
RETURN_ERROR(error);
// write to the settings file
error = settings.Flatten(&file);
if (error != B_OK)
RETURN_ERROR(error);
return B_OK;
}
BMessage* RemoveAttribute::Do(PDocument *doc, BMessage *settings)
{
BList *selection = doc->GetSelected();
BMessage *undoMessage = new BMessage();
BMessage *node = NULL;
BMessage *selectedNodes = new BMessage();
BMessage *valueContainer = new BMessage();
int32 i = 0;
bool selected = false;
status_t err = B_OK;
while (settings->FindPointer("node",i,(void **)&node) == B_OK)
{
if (settings->FindMessage("valueContainer",i,valueContainer) == B_OK)
DoRemoveAttribute(doc,node,valueContainer,undoMessage);
i++;
}
if ( (settings->FindBool("Node::selected",&selected) == B_OK) && (selected==true) )
{
if (settings->FindMessage("valueContainer",i,valueContainer) == B_OK)
{
for (int32 i=0;i<selection->CountItems();i++)
{
node =(BMessage *) selection->ItemAt(i);
selectedNodes->AddPointer("node",node);
DoRemoveAttribute(doc,node,valueContainer,selectedNodes);
}
}
}
undoMessage->AddMessage("selectedNodes",selectedNodes);
doc->SetModified();
settings->RemoveName("RemoveAttribute::Undo");
settings->AddMessage("RemoveAttribute::Undo",undoMessage);
settings = PCommand::Do(doc,settings);
return settings;
}
status_t
ThemeManager::UpdateTheme(int32 id, uint32 flags)
{
FENTRY;
int32 i;
ThemesAddon *ta;
status_t err, gerr = B_OK;
BMessage *theme;
BMessage infos;
BString loc;
if ((id < 0) || (id >= fThemeList.CountItems()))
return EINVAL;
theme = (BMessage *)fThemeList.ItemAt(id);
if (!theme)
return -1;
err = theme->FindMessage(Z_THEME_INFO_MESSAGE, &infos);
err = theme->FindString(Z_THEME_LOCATION, &loc);
if (err)
loc = "";
theme->MakeEmpty();
err = theme->AddMessage(Z_THEME_INFO_MESSAGE, &infos);
err = theme->AddString(Z_THEME_LOCATION, loc.String());
if (err)
return err;
for (i = 0; i < fAddonCount; i++) {
ta = (ThemesAddon *)fAddonList.ItemAt(i);
if (!ta)
continue;
if (!(ta->AddonFlags() & Z_THEME_ADDON_DO_RETRIEVE))
continue;
err = ta->MakeTheme(*theme, flags);
if (err)
gerr = err;
}
return B_OK;//gerr;
}
void
MainWindow::StoreSettings(BMessage& settings) const
{
settings.AddRect(_WindowFrameName(), Frame());
if (!fSinglePackageMode) {
settings.AddRect("window frame", Frame());
BMessage columnSettings;
fPackageListView->SaveState(&columnSettings);
settings.AddMessage("column settings", &columnSettings);
settings.AddBool("show featured packages",
fModel.ShowFeaturedPackages());
settings.AddBool("show available packages",
fModel.ShowAvailablePackages());
settings.AddBool("show installed packages",
fModel.ShowInstalledPackages());
settings.AddBool("show develop packages", fModel.ShowDevelopPackages());
settings.AddBool("show source packages", fModel.ShowSourcePackages());
}
settings.AddString("username", fModel.Username());
}
Partition *
AddMountableItemToMessage(Partition *partition, void *castToParams)
{
BMessage *message = static_cast<BMessage *>(castToParams);
message->AddString("DeviceName", partition->GetDevice()->Name());
const char *name;
if (*partition->VolumeName())
name = partition->VolumeName();
else if (*partition->Type())
name = partition->Type();
else
name = partition->GetDevice()->DisplayName();
message->AddString("DisplayName", name);
BMessage invokeMsg;
if (partition->GetDevice()->IsFloppy())
invokeMsg.what = kTryMountingFloppy;
else
invokeMsg.what = kMountVolume;
invokeMsg.AddInt32("id", partition->UniqueID());
message->AddMessage("InvokeMessage", &invokeMsg);
return NULL;
}
// MessageReceived
void
NetFSServer::MessageReceived(BMessage* message)
{
switch (message->what) {
case NETFS_REQUEST_GET_MESSENGER:
{
// for the time being we process all requests here
BMessage reply;
reply.AddMessenger("messenger", be_app_messenger);
_SendReply(message, &reply);
break;
}
case NETFS_REQUEST_ADD_USER:
{
// get user name and password
const char* user;
const char* password;
if (message->FindString("user", &user) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
if (message->FindString("password", &password) != B_OK)
password = NULL;
// add the user
status_t error = fSecurityContext->AddUser(user, password);
_SendReply(message, error);
break;
}
case NETFS_REQUEST_REMOVE_USER:
{
// get user name
const char* userName;
if (message->FindString("user", &userName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// remove the user
User* user;
status_t error = fSecurityContext->RemoveUser(userName, &user);
if (error == B_OK) {
// propagate the information to the client connections
AutoLocker<Locker> _(fLock);
for (int32 i = 0;
ClientConnection* connection
= (ClientConnection*)fClientConnections.ItemAt(i);
i++) {
connection->UserRemoved(user);
}
user->RemoveReference();
}
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_USERS:
{
// get the users
BMessage reply;
BMessage users;
status_t error = fSecurityContext->GetUsers(&users);
if (error == B_OK)
error = reply.AddMessage("users", &users);
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_USER_STATISTICS:
{
// get user name
const char* userName;
if (message->FindString("user", &userName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// get the user
User* user = fSecurityContext->FindUser(userName);
if (!user) {
_SendReply(message, B_ENTRY_NOT_FOUND);
break;
}
Reference<User> userReference(user, true);
// get the statistics
BMessage statistics;
status_t error = StatisticsManager::GetDefault()
->GetUserStatistics(user, &statistics);
// prepare the reply
BMessage reply;
if (error == B_OK)
error = reply.AddMessage("statistics", &statistics);
// send the reply
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_ADD_SHARE:
{
// get share name and path
const char* share;
const char* path;
if (message->FindString("share", &share) != B_OK
|| message->FindString("path", &path) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// add the share
status_t error = fSecurityContext->AddShare(share, path);
if (error == B_OK)
_ServerInfoUpdated();
_SendReply(message, error);
break;
}
case NETFS_REQUEST_REMOVE_SHARE:
{
// get share name
const char* shareName;
if (message->FindString("share", &shareName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// remove the share
Share* share;
status_t error = fSecurityContext->RemoveShare(shareName, &share);
if (error == B_OK) {
// propagate the information to the client connections
AutoLocker<Locker> _(fLock);
for (int32 i = 0;
ClientConnection* connection
= (ClientConnection*)fClientConnections.ItemAt(i);
i++) {
connection->ShareRemoved(share);
}
share->RemoveReference();
}
if (error == B_OK)
_ServerInfoUpdated();
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_SHARES:
{
// get the shares
BMessage reply;
BMessage shares;
status_t error = fSecurityContext->GetShares(&shares);
if (error == B_OK)
error = reply.AddMessage("shares", &shares);
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_SHARE_USERS:
{
// get share name
const char* shareName;
if (message->FindString("share", &shareName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
AutoLocker<Locker> securityContextLocker(fSecurityContext);
// get the share
Share* share = fSecurityContext->FindShare(shareName);
if (!share) {
_SendReply(message, B_ENTRY_NOT_FOUND);
break;
}
Reference<Share> shareReference(share, true);
// get all users
BMessage allUsers;
status_t error = fSecurityContext->GetUsers(&allUsers);
if (error != B_OK) {
_SendReply(message, error);
break;
}
// filter the users with mount permission
BMessage users;
const char* userName;
for (int32 i = 0;
allUsers.FindString("users", i, &userName) == B_OK;
i++) {
if (User* user = fSecurityContext->FindUser(userName)) {
// get the user's permissions
Permissions permissions = fSecurityContext
->GetNodePermissions(share->GetPath(), user);
user->RemoveReference();
// add the user, if they have the permission to mount the
// share
if (permissions.ImpliesMountSharePermission()) {
error = users.AddString("users", userName);
if (error != B_OK) {
_SendReply(message, error);
break;
}
}
}
}
securityContextLocker.Unlock();
// prepare the reply
BMessage reply;
if (error == B_OK)
error = reply.AddMessage("users", &users);
// send the reply
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_SHARE_STATISTICS:
{
// get share name
const char* shareName;
if (message->FindString("share", &shareName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// get the share
Share* share = fSecurityContext->FindShare(shareName);
if (!share) {
_SendReply(message, B_ENTRY_NOT_FOUND);
break;
}
Reference<Share> shareReference(share, true);
// get the statistics
BMessage statistics;
status_t error = StatisticsManager::GetDefault()
->GetShareStatistics(share, &statistics);
// prepare the reply
BMessage reply;
if (error == B_OK)
error = reply.AddMessage("statistics", &statistics);
// send the reply
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_SET_USER_PERMISSIONS:
{
// get share and user name, and the permissions
const char* shareName;
const char* userName;
uint32 permissions;
if (message->FindString("share", &shareName) != B_OK
|| message->FindString("user", &userName) != B_OK
|| message->FindInt32("permissions", (int32*)&permissions)
!= B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// get the share and the user
Share* share = fSecurityContext->FindShare(shareName);
User* user = fSecurityContext->FindUser(userName);
Reference<Share> shareReference(share);
Reference<User> userReference(user);
if (!share || !user) {
_SendReply(message, B_ENTRY_NOT_FOUND);
break;
}
// set the permissions
status_t error = B_OK;
if (permissions == 0) {
fSecurityContext->ClearNodePermissions(share->GetPath(), user);
} else {
error = fSecurityContext->SetNodePermissions(share->GetPath(),
user, permissions);
}
if (error == B_OK) {
// propagate the information to the client connections
AutoLocker<Locker> _(fLock);
for (int32 i = 0;
ClientConnection* connection
= (ClientConnection*)fClientConnections.ItemAt(i);
i++) {
connection->UserPermissionsChanged(share, user,
permissions);
}
}
_SendReply(message, error);
break;
}
case NETFS_REQUEST_GET_USER_PERMISSIONS:
{
// get share and user name
const char* shareName;
const char* userName;
if (message->FindString("share", &shareName) != B_OK
|| message->FindString("user", &userName) != B_OK) {
_SendReply(message, B_BAD_VALUE);
break;
}
// get the share and the user
Share* share = fSecurityContext->FindShare(shareName);
User* user = fSecurityContext->FindUser(userName);
Reference<Share> shareReference(share);
Reference<User> userReference(user);
if (!share || !user) {
_SendReply(message, B_ENTRY_NOT_FOUND);
break;
}
// get the permissions
Permissions permissions = fSecurityContext->GetNodePermissions(
share->GetPath(), user);
// prepare the reply
BMessage reply;
status_t error = reply.AddInt32("permissions",
(int32)permissions.GetPermissions());
// send it
if (error == B_OK)
_SendReply(message, &reply);
else
_SendReply(message, error);
break;
}
case NETFS_REQUEST_SAVE_SETTINGS:
{
status_t error = _SaveSettings();
// send a reply
_SendReply(message, error);
break;
}
}
}
bool
TTracker::QuitRequested()
{
// don't allow user quitting
if (CurrentMessage() && CurrentMessage()->FindBool("shortcut"))
return false;
gStatusWindow->AttemptToQuit();
// try quitting the copy/move/empty trash threads
BVolume bootVolume;
DEBUG_ONLY(status_t err =) BVolumeRoster().GetBootVolume(&bootVolume);
ASSERT(err == B_OK);
BMessage message;
AutoLock<WindowList> lock(&fWindowList);
// save open windows in a message inside an attribute of the desktop
int32 count = fWindowList.CountItems();
for (int32 i = 0; i < count; i++) {
BContainerWindow *window = dynamic_cast<BContainerWindow *>
(fWindowList.ItemAt(i));
if (window && window->TargetModel() && !window->PoseView()->IsDesktopWindow()) {
if (window->TargetModel()->IsRoot())
message.AddBool("open_disks_window", true);
else {
BEntry entry;
BPath path;
const entry_ref *ref = window->TargetModel()->EntryRef();
if (entry.SetTo(ref) == B_OK && entry.GetPath(&path) == B_OK) {
int8 flags = window->IsMinimized() ? kOpenWindowMinimized : kOpenWindowNoFlags;
uint32 deviceFlags = GetVolumeFlags(window->TargetModel());
// save state for every window which is
// a) already open on another workspace
// b) on a volume not capable of writing attributes
if (window != FindContainerWindow(ref)
|| (deviceFlags & (B_FS_HAS_ATTR | B_FS_IS_READONLY)) != B_FS_HAS_ATTR) {
BMessage stateMessage;
window->SaveState(stateMessage);
window->SetSaveStateEnabled(false);
// This is to prevent its state to be saved to the node when closed.
message.AddMessage("window state", &stateMessage);
flags |= kOpenWindowHasState;
}
const char *target;
bool pathAlreadyExists = false;
for (int32 index = 0;message.FindString("paths", index, &target) == B_OK;index++) {
if (!strcmp(target,path.Path())) {
pathAlreadyExists = true;
break;
}
}
if (!pathAlreadyExists)
message.AddString("paths", path.Path());
message.AddInt8(path.Path(), flags);
}
}
}
}
lock.Unlock();
// write windows to open on disk
BDirectory deskDir;
if (!BootedInSafeMode() && FSGetDeskDir(&deskDir, bootVolume.Device()) == B_OK) {
// if message is empty, delete the corresponding attribute
if (message.CountNames(B_ANY_TYPE)) {
size_t size = (size_t)message.FlattenedSize();
char *buffer = new char[size];
message.Flatten(buffer, (ssize_t)size);
deskDir.WriteAttr(kAttrOpenWindows, B_MESSAGE_TYPE, 0, buffer, size);
delete [] buffer;
} else
deskDir.RemoveAttr(kAttrOpenWindows);
}
for (int32 count = 0; count == 50; count++) {
// wait 5 seconds for the copiing/moving to quit
if (gStatusWindow->AttemptToQuit())
break;
snooze(100000);
}
return _inherited::QuitRequested();
}
status_t
TeamWindow::SaveSettings(GuiTeamUiSettings* settings)
{
AutoLocker<BWindow> lock(this);
if (!lock.IsLocked())
return B_ERROR;
BMessage inspectorSettings;
if (fUiSettings.Settings("inspectorWindow", inspectorSettings) == B_OK) {
if (!settings->AddSettings("inspectorWindow", inspectorSettings))
return B_NO_MEMORY;
}
BMessage archive;
BMessage teamWindowSettings;
if (teamWindowSettings.AddRect("frame", Frame()) != B_OK)
return B_NO_MEMORY;
if (GuiSettingsUtils::ArchiveSplitView(archive, fSourceSplitView) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("sourceSplit", &archive) != B_OK)
return B_NO_MEMORY;
if (GuiSettingsUtils::ArchiveSplitView(archive, fFunctionSplitView) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("functionSplit", &archive) != B_OK)
return B_NO_MEMORY;
if (GuiSettingsUtils::ArchiveSplitView(archive, fImageSplitView) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("imageSplit", &archive))
return B_NO_MEMORY;
if (GuiSettingsUtils::ArchiveSplitView(archive, fThreadSplitView) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("threadSplit", &archive))
return B_NO_MEMORY;
if (GuiSettingsUtils::ArchiveSplitView(archive, fConsoleSplitView) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("consoleSplit", &archive))
return B_NO_MEMORY;
if (fImageListView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("imageListView", &archive))
return B_NO_MEMORY;
if (fImageFunctionsView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("imageFunctionsView", &archive))
return B_NO_MEMORY;
if (fThreadListView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("threadListView", &archive))
return B_NO_MEMORY;
if (fVariablesView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("variablesView", &archive))
return B_NO_MEMORY;
if (fRegistersView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("registersView", &archive))
return B_NO_MEMORY;
if (fStackTraceView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("stackTraceView", &archive))
return B_NO_MEMORY;
if (fBreakpointsView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("breakpointsView", &archive))
return B_NO_MEMORY;
if (fConsoleOutputView->SaveSettings(archive) != B_OK)
return B_NO_MEMORY;
if (teamWindowSettings.AddMessage("consoleOutputView", &archive))
return B_NO_MEMORY;
if (!settings->AddSettings("teamWindow", teamWindowSettings))
return B_NO_MEMORY;
return B_OK;
}
bool
ServerAgent::ParseENums (const char *data, const char *sWord)
{
int num (atoi (sWord));
switch (num)
{
case ZERO: // 0
{
// wasn't a numeric, or the server is playing tricks on us
}
return false;
case ERR_UNKNOWNCOMMAND: // 421
{
BString tempString (RestOfString (data, 4)),
badCmd (GetWord (data, 4));
if (badCmd == "VISION_LAG_CHECK")
{
int32 difference (system_time() - fLagCheck);
if (difference > 0)
{
int32 secs (difference / 1000000);
int32 milli (difference / 1000 - secs * 1000);
char lag[15] = "";
sprintf (lag, "%0" B_PRId32 ".%03" B_PRId32, secs, milli);
fMyLag = lag;
fLagCount = 0;
fCheckingLag = false;
fMsgr.SendMessage (M_LAG_CHANGED);
}
}
else
{
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String());
}
}
return true;
case RPL_WELCOME: // 001
case RPL_YOURHOST: // 002
case RPL_CREATED: // 003
case RPL_MYINFO: // 004
{
fConnected = true;
fIsConnecting = false;
fInitialMotd = true;
fRetry = 0;
if (num == RPL_WELCOME)
{
BString message = B_TRANSLATE("Established");
message.Prepend("[@] ").Append("\n");
Display(message.String(), C_ERROR, C_BACKGROUND, F_SERVER);
}
if (fNetworkData.FindBool ("lagCheck"))
{
fMyLag = "0.000";
fMsgr.SendMessage (M_LAG_CHANGED);
}
BString theNick (GetWord (data, 3));
fMyNick = theNick;
if (!IsHidden())
vision_app->pClientWin()->pStatusView()->SetItemValue (STATUS_NICK,
theNick.String());
BString theMsg (RestOfString (data, 4));
theMsg.RemoveFirst (":");
theMsg.Prepend ("* ");
theMsg.Append ("\n");
Display (theMsg.String());
if (num == RPL_MYINFO)
{
// set "real" hostname
fServerHostName = (GetWord (data, 1));
fServerHostName.RemoveFirst (":");
BString hostName (fId.String());
hostName += " - [";
hostName += fServerHostName.String();
hostName += "]";
fAgentWinItem->SetName (hostName.String());
// detect IRCd
fIrcdtype = IRCD_STANDARD;
if (theMsg.FindFirst("hybrid") > 0)
fIrcdtype = IRCD_HYBRID;
// ultimate and unreal share the same numerics, so treat them with the same
// identifier for now
else if ((theMsg.FindFirst("UltimateIRCd") > 0) || (theMsg.FindFirst("Unreal") > 0))
fIrcdtype = IRCD_ULTIMATE;
else if (theMsg.FindFirst("comstud") > 0)
fIrcdtype = IRCD_COMSTUD;
else if (theMsg.FindFirst("u2.") > 0)
fIrcdtype = IRCD_UNDERNET;
else if (theMsg.FindFirst("PTlink") > 0)
fIrcdtype = IRCD_PTLINK;
else if (theMsg.FindFirst ("CR") > 0)
fIrcdtype = IRCD_CONFERENCEROOM;
else if (theMsg.FindFirst ("nn-") > 0)
fIrcdtype = IRCD_NEWNET;
}
}
return true;
case RPL_PROTOCTL: // 005
{
// this numeric also serves as RPL_NNMAP on Newnet
BString theMsg (RestOfString (data, 4));
theMsg.RemoveFirst (":");
theMsg.Append ("\n");
switch (fIrcdtype)
{
case IRCD_NEWNET:
{
// RPL_NNMAP
Display (theMsg.String());
}
break;
default:
{
// RPL_PROTOCTL
theMsg.Prepend ("* ");
Display (theMsg.String());
}
}
}
return true;
case RPL_LUSERHIGHESTCONN: // 250
case RPL_LUSERCLIENT: // 251
case RPL_LUSEROP: // 252
case RPL_LUSERUNKNOWN: // 253
case RPL_LUSERCHANNELS: // 254
case RPL_LUSERME: // 255
case RPL_LUSERLOCAL: // 265
case RPL_LUSERGLOBAL: // 266
{
BString theMsg (RestOfString (data, 4));
theMsg.RemoveFirst (":");
theMsg.Prepend ("* ");
theMsg.Append ("\n");
Display (theMsg.String());
}
return true;
/// strip and send to server agent ///
case RPL_ULMAP: // 006
case RPL_ULMAPEND: // 007
case RPL_U2MAP: // 015
case RPL_U2MAPEND: // 017
case RPL_TRACELINK: // 200
case RPL_TRACECONNECTING: // 201
case RPL_TRACEHANDSHAKE: // 202
case RPL_TRACEUNKNOWN: // 203
case RPL_TRACEOPERATOR: // 204
case RPL_TRACEUSER: // 205
case RPL_TRACESERVER: // 206
case RPL_TRACENEWTYPE: // 208
case RPL_TRACECLASS: // 209
case RPL_STATSLINKINFO: // 211
case RPL_STATSCOMMANDS: // 212
case RPL_STATSCLINE: // 213
case RPL_STATSNLINE: // 214
case RPL_STATSILINE: // 215
case RPL_STATSKLINE: // 216
case RPL_STATSQLINE: // 217
case RPL_STATSYLINE: // 218
case RPL_ENDOFSTATS: // 219
case RPL_STATSBLINE: // 220
case RPL_DALSTATSE: // 223
case RPL_DALSTATSF: // 224
case RPL_DALSTATSZ: // 225
case RPL_DALSTATSN: // 226
case RPL_DALSTATSG: // 227
case RPL_STATSLLINE: // 241
case RPL_STATSUPTIME: // 242
case RPL_STATSOLINE: // 243
case RPL_STATSHLINE: // 244
case RPL_STATSSLINE: // 245
case RPL_DALSTATSX: // 246
case RPL_STATSXLINE: // 247
case RPL_STATSPLINE: // 249
case RPL_ADMINME: // 256
case RPL_ADMINLOC1: // 257
case RPL_ADMINLOC2: // 258
case RPL_ADMINEMAIL: // 259
case RPL_TRACELOG: // 261
case RPL_ENDOFTRACE: // 262
case RPL_SILELIST: // 271
case RPL_ENDOFSILELIST: // 272
case RPL_ENDOFWHO: // 315
case RPL_CHANSERVURL: // 328
case RPL_COMMANDSYNTAX: // 334
case RPL_VERSION: // 351
case RPL_WHOREPLY: // 352
case RPL_BANLIST: // 367
case RPL_ENDOFBANLIST: // 368
case RPL_INFO: // 371
case RPL_ENDOFINFO: // 374
case RPL_YOUREOPER: // 381
case RPL_REHASHING: // 382
case RPL_TIME: // 391
case ERR_NOORIGIN: // 409
case ERR_NOTEXTTOSEND: // 412
case ERR_TOOMANYAWAY: // 429
case ERR_NICKCHANGETOOFAST: // 438
case ERR_TARGETCHANGETOOFAST: // 439
case ERR_SUMMONDISABLED: // 445
case ERR_USERSDISABLED: // 446
case ERR_NOTREGISTERED: // 451
case ERR_NEEDMOREPARMS: // 461
case ERR_PASSWDMISMATCH: // 464
case ERR_YOUREBANNEDCREEP: // 465
case ERR_NOPRIVILEGES: // 481
case ERR_NOOPERHOST: // 491
case ERR_USERSDONTMATCH: // 502
case ERR_SILELISTFULL: // 511
case ERR_TOOMANYWATCH: // 512
case ERR_TOOMANYDCC: // 514
case ERR_CANTINVITE: // 518
case ERR_LISTSYNTAX: // 521
case ERR_WHOSYNTAX: // 522
case ERR_WHOLIMEXCEED: // 523
case RPL_LOGON: // 600
case RPL_LOGOFF: // 601
case RPL_WATCHOFF: // 602
case RPL_WATCHSTAT: // 603
case RPL_NOWON: // 604
case RPL_NOWOFF: // 605
case RPL_WATCHLIST: // 606
case RPL_ENDOFWATCHLIST: // 607
case RPL_DCCALLOWLIST: // 618
case RPL_DCCALLOWEND: // 619
case RPL_DCCALLOW: // 620
{
BString tempString (RestOfString (data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String());
}
return true;
case RPL_UMODEIS: // 221
{
BString theMode (GetWord (data, 4));
BString tempString = B_TRANSLATE("Your current mode is %1");
tempString.ReplaceFirst("%1", theMode);
tempString += '\n';
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS);
PostActive (&msg);
}
return true;
/// strip and send to active agent ///
case RPL_TRYAGAIN: // 263
case RPL_UNAWAY: // 305
case RPL_NOWAWAY: // 306
case ERR_NOSUCHNICK: // 401
case ERR_NOSUCHSERVER: // 402
case ERR_NOSUCHCHANNEL: // 403
case ERR_CANNOTSENDTOCHAN: // 404
case ERR_TOOMANYCHANNELS: // 405
case ERR_WASNOSUCHNICK: // 406
case ERR_TOOMANYTARGETS: // 407
case ERR_NOCOLORSONCHAN: // 408
case ERR_YOUCANTDOTHAT: // 460
case ERR_CHANOPRIVSNEEDED: // 482
{
BString tempString ("[x] ");
if (num == ERR_CHANOPRIVSNEEDED)
tempString += RestOfString (data, 5);
else
tempString += RestOfString (data, 4);
tempString.RemoveFirst (":");
tempString.Append ("\n");
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
}
return true;
case RPL_AWAY: // 301
{
BString theNick (GetWord(data, 4));
BString tempString ("[x] "),
theReason (RestOfString(data, 5));
theReason.RemoveFirst(":");
tempString += "Away: ";
tempString += theReason;
tempString += '\n';
if (fRemoteAwayMessages.find(theNick) != fRemoteAwayMessages.end())
{
if (fRemoteAwayMessages[theNick] == theReason)
{
return true;
}
}
fRemoteAwayMessages[theNick] = theReason;
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
}
return true;
case RPL_USERHOST: // 302
{
BString theHost (GetWord (data, 4)),
theHostname (GetAddress (theHost.String()));
theHost.RemoveFirst (":");
BString tempString (RestOfString (data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String());
if (fGetLocalIP && (tempString.IFindFirst (fMyNick.String()) == 0))
{
fGetLocalIP = false;
struct addrinfo *info;
struct addrinfo hints;
memset(&hints, 0, sizeof(addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
int result = getaddrinfo(theHostname.String(), NULL, &hints, &info);
if (result == 0)
{
char addr_buf[INET6_ADDRSTRLEN];
getnameinfo(info->ai_addr, info->ai_addrlen, addr_buf, sizeof(addr_buf),
NULL, 0, NI_NUMERICHOST);
fLocalip = addr_buf;
printf("Got address: %s\n", fLocalip.String());
freeaddrinfo(info);
return true;
}
}
}
return true;
case RPL_ISON: // 303
{
BString nicks (RestOfString (data, 4));
BString onlined, offlined;
nicks.RemoveFirst (":");
int hasChanged (0);
BMessage msg (M_NOTIFYLIST_UPDATE);
for (int32 i = 0; i < fNotifyNicks.CountItems(); i++)
{
NotifyListItem *item (((NotifyListItem *)fNotifyNicks.ItemAt(i)));
int32 nickidx (nicks.IFindFirst(item->Text()));
// make sure that the nick isn't a partial match.
if ((nickidx >= 0) &&
((nicks[nickidx + strlen(item->Text())] == ' ') || (nicks[nickidx + strlen(item->Text())] == '\0')))
{
if (item->GetState() != true)
{
item->SetState (true);
hasChanged = 1;
if (onlined.Length())
onlined << ", ";
onlined << item->Text();
#ifdef USE_INFOPOPPER
if (be_roster->IsRunning(InfoPopperAppSig) == true) {
entry_ref ref = vision_app->AppRef();
BMessage infoMsg(InfoPopper::AddMessage);
infoMsg.AddString("appTitle", S_INFOPOPPER_TITLE);
infoMsg.AddString("title", fId.String());
infoMsg.AddInt8("type", (int8)InfoPopper::Information);
infoMsg.AddInt32("iconType", InfoPopper::Attribute);
infoMsg.AddRef("iconRef", &ref);
BString content;
content << item->Text() << " is online";
infoMsg.AddString("content", content);
BMessenger(InfoPopperAppSig).SendMessage(&infoMsg);
};
#endif
}
}
else
{
if (item->GetState() == true)
{
item->SetState (false);
hasChanged = 2;
if (offlined.Length())
offlined << ", ";
offlined << item->Text();
#ifdef USE_INFOPOPPER
if (be_roster->IsRunning(InfoPopperAppSig) == true) {
entry_ref ref = vision_app->AppRef();
BMessage infoMsg(InfoPopper::AddMessage);
infoMsg.AddString("appTitle", S_INFOPOPPER_TITLE);
infoMsg.AddString("title", fId.String());
infoMsg.AddInt8("type", (int8)InfoPopper::Information);
infoMsg.AddInt32("iconType", InfoPopper::Attribute);
infoMsg.AddRef("iconRef", &ref);
BString content;
content << item->Text() << " is offline";
infoMsg.AddString("content", content);
BMessenger(InfoPopperAppSig).SendMessage(&infoMsg);
};
#endif
}
}
#ifdef __HAIKU__
if (offlined.Length())
{
BNotification notification(B_INFORMATION_NOTIFICATION);
notification.SetGroup(BString("Vision"));
entry_ref ref = vision_app->AppRef();
notification.SetOnClickFile(&ref);
notification.SetTitle(fServerName.String());
BString content;
content << offlined;
if (offlined.FindFirst(' ') > -1)
content << " are offline";
else
content << " is offline";
notification.SetContent(content);
notification.Send();
}
if (onlined.Length())
{
BNotification notification(B_INFORMATION_NOTIFICATION);
notification.SetGroup(BString("Vision"));
entry_ref ref = vision_app->AppRef();
notification.SetOnClickFile(&ref);
notification.SetTitle(fServerName.String());
BString content;
content << onlined;
if (onlined.FindFirst(' ') > -1)
content << " are online";
else
content << " is online";
notification.SetContent(content);
notification.Send();
}
#endif
}
fNotifyNicks.SortItems(SortNotifyItems);
msg.AddPointer ("list", &fNotifyNicks);
msg.AddPointer ("source", this);
msg.AddInt32 ("change", hasChanged);
Window()->PostMessage (&msg);
}
return true;
case RPL_WHOISIDENTIFIED: // 307
{
BString theInfo (RestOfString (data, 5));
theInfo.RemoveFirst (":");
if (theInfo == "-9z99")
{
// USERIP reply? (RPL_U2USERIP)
BString tempString (RestOfString (data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String());
return true;
}
BMessage display (M_DISPLAY);
BString buffer;
buffer += "[x] ";
buffer += theInfo;
buffer += "\n";
PackDisplay (&display, buffer.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&display);
}
return true;
case RPL_WHOISADMIN: // 308
case RPL_WHOISSERVICESADMIN: // 309
case RPL_WHOISHELPOP: // 310
case RPL_WHOISOPERATOR: // 313
case RPL_WHOISREGNICK: // 320
case RPL_WHOISACTUALLY: // 338
case RPL_WHOISMASK: // 550
case RPL_WHOWASIP: // 612
case RPL_WHOISUSERMODESALT: // 614
case RPL_WHOISUSERMODES: // 615
case RPL_WHOISREALHOSTNAME: // 616
{
BString theInfo (RestOfString (data, 5));
theInfo.RemoveFirst (":");
BMessage display (M_DISPLAY);
BString buffer;
buffer += "[x] ";
buffer += theInfo;
buffer += "\n";
PackDisplay (&display, buffer.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&display);
}
return true;
case RPL_WHOISUSER: // 311
{
BString theNick (GetWord (data, 4)),
theIdent (GetWord (data, 5)),
theAddress (GetWord (data, 6)),
theName (RestOfString (data, 8));
theName.RemoveFirst (":");
BMessage display (M_DISPLAY);
BString buffer;
buffer += "[x] ";
buffer += theNick;
buffer += " (";
buffer += theIdent;
buffer += "@";
buffer += theAddress;
buffer += ")\n";
buffer += "[x] ";
buffer += theName;
buffer += "\n";
PackDisplay (&display, buffer.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&display);
}
return true;
case RPL_WHOISSERVER: // 312
{
BString theNick (GetWord (data, 4)),
theServer (GetWord (data, 5)),
theInfo (RestOfString (data, 6));
theInfo.RemoveFirst (":");
BMessage display (M_DISPLAY);
BString buffer;
buffer += "[x] Server: ";
buffer += theServer;
buffer += " (";
buffer += theInfo;
buffer += ")\n";
PackDisplay (&display, buffer.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&display);
}
return true;
case RPL_WHOWASUSER: // 314
{
BString theNick (GetWord (data, 4)),
theIdent (GetWord (data, 5)),
theAddress (GetWord (data, 6)),
theName (RestOfString (data, 8)),
tempString ("[x] ");
theName.RemoveFirst (":");
tempString += B_TRANSLATE("%1 was (%2)");
tempString.ReplaceFirst("%1", theNick);
BString nickString = theIdent << "@" << theAddress;
tempString.ReplaceFirst("%2", nickString.String());
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
}
return true;
case RPL_WHOISIDLE: // 317
{
BString theNick (GetWord (data, 4)),
tempString ("[x] "),
tempString2 ("[x] "),
theTime (GetWord (data, 5)),
signOnTime (GetWord (data, 6));
int64 idleTime (strtoul(theTime.String(), NULL, 0));
tempString += B_TRANSLATE("Idle");
tempString += ": ";
tempString += DurationString(idleTime * 1000 * 1000);
tempString += "\n";
int32 serverTime = strtoul(signOnTime.String(), NULL, 0);
struct tm ptr;
time_t st;
char str[80];
st = serverTime;
localtime_r (&st, &ptr);
strftime (str,80,"%A %b %d %Y %I:%M %p %Z", &ptr);
BString signOnTimeParsed (str);
signOnTimeParsed.RemoveAll ("\n");
tempString2 += B_TRANSLATE("Signon");
tempString2 += ": ";
tempString2 += signOnTimeParsed;
tempString2 += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
PackDisplay (&msg, tempString2.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
}
return true;
case RPL_ENDOFWHOIS: // 318
case RPL_ENDOFNAMES: // 366
case RPL_ENDOFWHOWAS: // 369
{
// nothing
}
return true;
case RPL_WHOISCHANNELS: // 319
{
BString theChannels (RestOfString (data, 5));
theChannels.RemoveFirst(":");
BMessage display (M_DISPLAY);
BString buffer = "[x] ";
buffer += B_TRANSLATE("Channels");
buffer += ": ";
buffer += theChannels;
buffer += "\n";
PackDisplay (&display, buffer.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&display);
}
return true;
case RPL_LISTSTART: // 321
{
BMessage msg (M_LIST_BEGIN);
if (fListAgent)
vision_app->pClientWin()->DispatchMessage(&msg, (BView *)fListAgent);
}
return true;
case RPL_LIST: // 322
{
BMessage msg (M_LIST_EVENT);
BString channel (GetWord (data, 4)),
users (GetWord (data, 5)),
topic (RestOfString (data, 6));
topic.RemoveFirst (":");
msg.AddString ("channel", channel.String());
msg.AddString ("users", users.String());
msg.AddString ("topic", topic.String());
if (fListAgent)
vision_app->pClientWin()->DispatchMessage(&msg, (BView *)fListAgent);
}
return true;
case RPL_LISTEND: // 323
{
BMessage msg (M_LIST_DONE);
if (fListAgent)
vision_app->pClientWin()->DispatchMessage(&msg, (BView *)fListAgent);
}
return true;
case RPL_CHANNELMODEIS: // 324
{
BString theChan (GetWord (data, 4)),
theMode (GetWord (data, 5)),
tempStuff (RestOfString (data, 6));
if (tempStuff != "-9z99")
{
theMode.Append(" ");
theMode.Append(tempStuff); // avoid extra space w/o params
}
ClientAgent *aClient (ActiveClient()),
*theClient (Client (theChan.String()));
BString tempString("*** ");
tempString += B_TRANSLATE("Channel mode for %1: %2");
tempString.ReplaceFirst("%1", theChan.String());
tempString.ReplaceFirst("%2", theMode.String());
tempString += '\n';
BMessage msg (M_CHANNEL_MODES);
msg.AddString ("msgz", tempString.String());
msg.AddString ("chan", theChan.String());
msg.AddString ("mode", theMode.String());
if (theClient)
theClient->fMsgr.SendMessage (&msg);
else if (aClient)
aClient->fMsgr.SendMessage (&msg);
else
Display (tempString.String(), C_OP);
}
return true;
case RPL_CHANNELMLOCK: // 325
{
BString theChan (GetWord (data, 4)),
mLock (GetWord (data, 8)),
lockMessage ("*** ");
lockMessage += B_TRANSLATE("Channel mode lock for %1: %2");
lockMessage.ReplaceFirst("%1", theChan);
lockMessage.ReplaceFirst("%2", mLock);
lockMessage += "\n";
BMessage display (M_DISPLAY);
PackDisplay (&display, lockMessage.String(), C_OP, C_BACKGROUND, F_TEXT);
ClientAgent *theClient (Client (theChan.String()));
if (theClient)
theClient->fMsgr.SendMessage (&display);
else
fMsgr.SendMessage (&display);
}
return true;
case RPL_CHANNELCREATED: // 329
{
BString theChan (GetWord (data, 4)),
theTime (GetWord (data, 5)),
tempString;
int32 serverTime (strtoul(theTime.String(), NULL, 0));
struct tm ptr;
time_t st;
char str[80];
st = serverTime;
localtime_r (&st, &ptr);
strftime (str,80,"%a %b %d %Y %I:%M %p %Z",&ptr);
BString theTimeParsed (str);
theTimeParsed.RemoveAll ("\n");
tempString = B_TRANSLATE("Channel %1 was created at %2");
tempString.ReplaceFirst("%1", theChan);
tempString.ReplaceFirst("%2", theTimeParsed);
tempString += '\n';
Display (tempString.String());
}
return true;
case RPL_NOTOPIC: // 331
{
BString theChan (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("No topic set in %1");
tempString.ReplaceFirst("%1", theChan);
tempString += '\n';
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_ERROR);
PostActive (&msg);
}
return true;
case RPL_TOPIC: // 332
{
BString theChannel (GetWord (data, 4)),
theTopic (RestOfString (data, 5));
ClientAgent *client (Client (theChannel.String()));
theTopic.RemoveFirst (":");
if (client)
{
BMessage display (M_DISPLAY);
BString buffer;
buffer += "*** ";
buffer += B_TRANSLATE("Topic: %1");
buffer.ReplaceFirst("%1", theTopic);
buffer += '\n';
PackDisplay (&display, buffer.String(), C_WHOIS);
BMessage msg (M_CHANNEL_TOPIC);
msg.AddString ("topic", theTopic.String());
msg.AddMessage ("display", &display);
if (client->fMsgr.IsValid())
client->fMsgr.SendMessage (&msg);
}
}
return true;
case RPL_TOPICSET: // 333
{
BString channel (GetWord (data, 4)),
user (GetWord (data, 5)),
theTime (GetWord (data, 6));
int32 serverTime (strtoul(theTime.String(), NULL, 0));
struct tm ptr;
time_t st;
char str[80];
st = serverTime;
localtime_r (&st, &ptr);
strftime (str,80,"%A %b %d %Y %I:%M %p %Z",&ptr);
BString theTimeParsed (str);
theTimeParsed.RemoveAll ("\n");
ClientAgent *client (Client (channel.String()));
if (client)
{
BMessage display (M_DISPLAY);
BString buffer = "*** ";
buffer += B_TRANSLATE("Topic set by %1 at %2");
buffer.ReplaceFirst("%1", user);
buffer.ReplaceFirst("%2", theTimeParsed);
buffer += '\n';
PackDisplay (&display, buffer.String(), C_WHOIS);
if (client->fMsgr.IsValid())
client->fMsgr.SendMessage (&display);
}
}
return true;
case RPL_INVITING: // 341
{
BString channel (GetWord (data, 5)),
theNick (GetWord (data, 4)),
tempString;
tempString += "*** ";
tempString += B_TRANSLATE("%1 has been invited to %2.");
tempString.ReplaceFirst("%1", theNick);
tempString.ReplaceFirst("%2", channel);
tempString += "\n";
BMessage display (M_DISPLAY);
PackDisplay (&display, tempString.String(), C_WHOIS);
PostActive (&display);
}
return true;
case RPL_NAMEREPLY: // 353
{
BString channel (GetWord (data, 5)),
names (RestOfString (data, 6));
ClientAgent *client (Client (channel.String()));
names.RemoveFirst (":");
BString tempString ("*** ");
tempString += B_TRANSLATE("Users in %1: %2");
tempString.ReplaceFirst("%1", channel);
tempString.ReplaceFirst("%2", names);
tempString += '\n';
Display (tempString.String(), C_TEXT);
if (client) // in the channel
{
BMessage msg (M_CHANNEL_NAMES);
BString nick;
int32 place (1);
while ((nick = GetWord (names.String(), place)) != "-9z99")
{
const char *sNick (nick.String());
bool founder (false),
protect (false),
op (false),
voice (false),
helper (false),
ignored;
if (nick[0] == '*')
{
++sNick;
founder = true;
}
else if (nick[0] == '!')
{
++sNick;
protect = true;
}
else if (nick[0] == '@')
{
++sNick;
op = true;
}
else if (nick[0] == '+')
{
++sNick;
voice = true;
}
else if (nick[0] == '%')
{
++sNick;
helper = true;
}
ignored = false;
// BMessage aMsg (M_IS_IGNORED), reply;
// aMsg.AddString ("server", fServerName.String());
// aMsg.AddString ("nick", sNick);
// be_app_messenger.SendMessage (&aMsg, &reply);
// reply.FindBool ("ignored", &ignored);
msg.AddString ("nick", nick.String());
msg.AddBool ("founder", founder);
msg.AddBool ("protect", protect);
msg.AddBool ("op", op);
msg.AddBool ("voice", voice);
msg.AddBool ("helper", helper);
msg.AddBool ("ignored", ignored);
++place;
}
if (client->fMsgr.IsValid())
client->fMsgr.SendMessage (&msg);
}
}
return true;
case RPL_MOTD: // 372
case RPL_MOTDALT: // 378
case RPL_OPERMOTDSTART: // 609
case RPL_OPERMOTD: // 610
case RPL_OPERENDOFMOTD: // 611
{
BString tempString (RestOfString(data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String(), C_SERVER, C_BACKGROUND, F_SERVER);
}
return true;
case RPL_MOTDSTART: // 375
{
BString tempString ("- ");
tempString += B_TRANSLATE("Server Message Of the Day");
tempString += ":\n";
Display (tempString.String(), C_SERVER, C_BACKGROUND, F_SERVER);
}
return true;
case RPL_ENDOFMOTD: // 376
case ERR_NOMOTD: // 422
{
BString tempString (RestOfString (data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
Display (tempString.String(), C_SERVER, C_BACKGROUND, F_SERVER);
if (fInitialMotd && fCmds.Length())
{
BMessage msg (M_SUBMIT_INPUT);
const char *place (fCmds.String()), *eol;
msg.AddInt32 ("which", PASTE_MULTI_NODELAY);
while ((eol = strchr (place, '\n')) != 0)
{
BString line;
line.Append (place, eol - place);
msg.AddString ("data", line.String());
ParseAutoexecChans (line);
place = eol + 1;
}
if (*place)
{
// check in case this was the only line
ParseAutoexecChans (BString(place));
msg.AddString ("data", place);
}
msg.AddInt32 ("which", 3);
msg.AddBool ("autoexec", true);
fMsgr.SendMessage (&msg);
}
BString IPCommand ("/userhost ");
IPCommand += fMyNick;
ParseCmd (IPCommand.String());
if (fReconnecting)
{
BString reString = "[@] ";
reString += B_TRANSLATE("Successful reconnect");
reString += "\n";
Display (reString.String(), C_ERROR);
DisplayAll (reString.String(), C_ERROR, C_BACKGROUND, F_SERVER);
fMsgr.SendMessage (M_REJOIN_ALL);
fReconnecting = false;
}
fInitialMotd = false;
}
return true;
case RPL_USERSSTART: // 392
{
// empty for now
}
return true;
case RPL_USERS: // 393
{
// empty for now
}
return true;
case ERR_ERRONEOUSNICKNAME: // 432
case ERR_NICKNAMEINUSE: // 433
case ERR_RESOURCEUNAVAILABLE: // 437
{
BString theNick (GetWord (data, 4));
if (fIsConnecting)
{
BString nextNick (GetNextNick());
if (nextNick != "")
{
BString tempString = "* ";
tempString += B_TRANSLATE("Nickname \"%1\" in use or unavailable, trying \"%2\"");
tempString.ReplaceFirst("%1", theNick.String());
tempString.ReplaceFirst("%2", nextNick.String());
tempString += "\n";
Display (tempString.String());
tempString = "NICK ";
tempString += nextNick;
SendData (tempString.String());
return true;
}
else
{
BString tempString = "* ";
tempString += B_TRANSLATE("All your pre-selected nicknames are in use.");
tempString += "\n";
Display (tempString.String());
tempString = "* ";
tempString += B_TRANSLATE("Please type /NICK <NEWNICK> to try another.");
tempString += "\n";
Display (tempString.String());
return true;
}
}
BString tempString = "[x] ";
tempString += B_TRANSLATE("Nickname/Channel \"%1\" is already in use or unavailable.");
tempString.ReplaceFirst("%1", theNick);
tempString += "\n";
BMessage display (M_DISPLAY);
PackDisplay (&display, tempString.String(), C_NICK);
PostActive (&display);
}
return true;
case ERR_USERNOTINCHANNEL: // 441
{
BString theChannel (GetWord (data, 5)),
theNick (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("%1 not in %2.");
tempString.ReplaceFirst("%1", theNick);
tempString.ReplaceFirst("%2", theChannel);
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_ERROR);
PostActive (&msg);
}
return true;
case ERR_NOTONCHANNEL: // 442
{
BString theChannel (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("You're not in %1.");
tempString.ReplaceFirst("%1", theChannel);
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_ERROR);
PostActive (&msg);
}
return true;
case ERR_USERONCHANNEL: // 443
{
BString theChannel (GetWord (data, 5)),
theNick (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("%1 is already in %2.");
tempString.ReplaceFirst("%1", theNick);
tempString.ReplaceFirst("%2", theChannel);
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_ERROR);
PostActive (&msg);
}
return true;
case ERR_KEYSET: // 467
{
BString theChannel (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("Channel key already set in %1.");
tempString.ReplaceFirst("%1", theChannel);
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_ERROR);
PostActive (&msg);
}
return true;
case ERR_UNKNOWNMODE: // 472
{
BString theMode (GetWord (data, 4)),
tempString ("[x] ");
tempString += B_TRANSLATE("Unknown channel mode: '%1'.");
tempString.ReplaceFirst("%1", theMode);
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_QUIT);
PostActive (&msg);
}
return true;
case ERR_INVITEONLYCHAN: // 473
{
BString theChan (GetWord (data, 4)),
tempString ("[x] "),
theReason (RestOfString (data, 5));
theReason.RemoveFirst(":");
theReason.ReplaceLast("channel", theChan.String());
tempString << theReason < " ";
tempString += B_TRANSLATE("(invite only)");
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_QUIT, C_BACKGROUND, F_SERVER);
PostActive (&msg);
RemoveAutoexecChan (theChan);
}
return true;
case ERR_BANNEDFROMCHAN: // 474
{
BString theChan (GetWord (data, 4)),
tempString ("[x] "),
theReason (RestOfString (data, 5));
theReason.RemoveFirst(":");
theReason.ReplaceLast("channel", theChan.String());
tempString << theReason < " ";
tempString += B_TRANSLATE("(you're banned)");
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_QUIT, C_BACKGROUND, F_SERVER);
PostActive (&msg);
RemoveAutoexecChan (theChan);
}
return true;
case ERR_BADCHANNELKEY: // 475
{
BString theChan (GetWord(data, 4)),
theReason (RestOfString(data, 5)),
tempString("[x] ");
theReason.RemoveFirst(":");
theReason.ReplaceLast("channel", theChan.String());
tempString << theReason << " ";
tempString += B_TRANSLATE("(bad channel key)");
tempString += "\n";
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_QUIT, C_BACKGROUND, F_SERVER);
PostActive (&msg);
RemoveAutoexecChan (theChan);
}
return true;
case ERR_UMODEUNKNOWNFLAG: // 501
{
BMessage msg (M_DISPLAY);
BString buffer = "[x] ";
buffer += B_TRANSLATE("Unknown mode flag.");
buffer += "\n";
PackDisplay (&msg, buffer.String(), C_QUIT);
PostActive (&msg);
}
return true;
// not sure what these numerics are,
// but they are usually on-connect messages
case RPL_290: // 290
case RPL_291: // 291
case RPL_292: // 292
{
BString tempString (RestOfString(data, 4));
tempString.RemoveFirst (":");
tempString.Append ("\n");
tempString.Prepend ("- ");
Display (tempString.String());
}
return true;
case RPL_WHOISREGISTEREDBOT: // 617
{
// conflicts with RPL_DCCALLOWCHANGE
BString theNick (GetWord (data, 4)),
theMessage (RestOfString (data, 5)),
tempString;
theNick.RemoveFirst (":");
theMessage.RemoveFirst (":");
theMessage.Append ("\n");
switch (fIrcdtype)
{
case IRCD_ULTIMATE:
{
tempString += "[@] ";
tempString += theMessage;
BMessage msg (M_DISPLAY);
PackDisplay (&msg, tempString.String(), C_WHOIS, C_BACKGROUND, F_SERVER);
PostActive (&msg);
}
break;
default:
{
tempString += theNick;
tempString += " ";
tempString += theMessage;
Display (tempString.String());
}
}
}
return true;
default:
break;
}
return false;
}
void VBoxClipboardService::MessageReceived(BMessage *message)
{
uint32_t formats = 0;
message->PrintToStream();
switch (message->what)
{
case VBOX_GUEST_CLIPBOARD_HOST_MSG_FORMATS:
{
int rc;
uint32_t cb;
void *pv;
bool commit = false;
if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
break;
if (!formats)
break;
if (!be_clipboard->Lock())
break;
be_clipboard->Clear();
BMessage *clip = be_clipboard->Data();
if (!clip)
{
be_clipboard->Unlock();
break;
}
if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
{
pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &cb);
if (pv)
{
char *text;
rc = RTUtf16ToUtf8((PCRTUTF16)pv, &text);
if (RT_SUCCESS(rc))
{
BString str(text);
/** @todo user vboxClipboardUtf16WinToLin() */
// convert Windows CRLF to LF
str.ReplaceAll("\r\n", "\n");
// don't include the \0
clip->AddData("text/plain", B_MIME_TYPE, str.String(), str.Length());
RTStrFree(text);
commit = true;
}
free(pv);
}
}
if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
{
pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &cb);
if (pv)
{
void *pBmp = NULL;
size_t cbBmp = 0;
rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmp);
if (RT_SUCCESS(rc))
{
BMemoryIO mio(pBmp, cbBmp);
BBitmap *bitmap = BTranslationUtils::GetBitmap(&mio);
if (bitmap)
{
BMessage bitmapArchive;
/** @todo r=ramshankar: split this into functions with error checking as
* neccessary. */
if ( bitmap->IsValid()
&& bitmap->Archive(&bitmapArchive) == B_OK
&& clip->AddMessage("image/bitmap", &bitmapArchive) == B_OK)
{
commit = true;
}
delete bitmap;
}
RTMemFree(pBmp);
}
free(pv);
}
}
/*
* Make sure we don't bounce this data back to the host, it's impolite. It can also
* be used as a hint to applications probably.
*/
clip->AddBool("FromVirtualBoxHost", true);
if (commit)
be_clipboard->Commit();
be_clipboard->Unlock();
break;
}
case VBOX_GUEST_CLIPBOARD_HOST_MSG_READ_DATA:
{
int rc;
if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
break;
if (!formats)
break;
if (!be_clipboard->Lock())
break;
BMessage *clip = be_clipboard->Data();
if (!clip)
{
be_clipboard->Unlock();
break;
}
clip->PrintToStream();
if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
{
const char *text;
int32 textLen;
if (clip->FindData("text/plain", B_MIME_TYPE, (const void **)&text, &textLen) == B_OK)
{
// usually doesn't include the \0 so be safe
BString str(text, textLen);
// convert from LF to Windows CRLF
str.ReplaceAll("\n", "\r\n");
PRTUTF16 pwsz;
rc = RTStrToUtf16(str.String(), &pwsz);
if (RT_SUCCESS(rc))
{
uint32_t cb = (RTUtf16Len(pwsz) + 1) * sizeof(RTUTF16);
rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, pwsz, cb);
//printf("VbglR3ClipboardWriteData: %d\n", rc);
RTUtf16Free(pwsz);
}
}
}
else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
{
BMessage archivedBitmap;
if (clip->FindMessage("image/bitmap", &archivedBitmap) == B_OK ||
clip->FindMessage("image/x-be-bitmap", &archivedBitmap) == B_OK)
{
BBitmap *bitmap = new(std::nothrow) BBitmap(&archivedBitmap);
if (bitmap)
{
// Don't delete bitmap, BBitmapStream will.
BBitmapStream stream(bitmap);
BTranslatorRoster *roster = BTranslatorRoster::Default();
if (roster && bitmap->IsValid())
{
BMallocIO bmpStream;
if (roster->Translate(&stream, NULL, NULL, &bmpStream, B_BMP_FORMAT) == B_OK)
{
const void *pDib;
size_t cbDibSize;
/* Strip out the BM header */
rc = vboxClipboardBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
if (RT_SUCCESS(rc))
{
rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib,
cbDibSize);
}
}
}
}
}
}
be_clipboard->Unlock();
break;
}
case B_CLIPBOARD_CHANGED:
{
printf("B_CLIPBOARD_CHANGED\n");
const void *data;
int32 dataLen;
if (!be_clipboard->Lock())
break;
BMessage *clip = be_clipboard->Data();
if (!clip)
{
be_clipboard->Unlock();
break;
}
bool fromVBox;
if (clip->FindBool("FromVirtualBoxHost", &fromVBox) == B_OK && fromVBox)
{
// It already comes from the host, discard.
be_clipboard->Unlock();
break;
}
if (clip->FindData("text/plain", B_MIME_TYPE, &data, &dataLen) == B_OK)
formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
if ( clip->HasMessage("image/bitmap")
|| clip->HasMessage("image/x-be-bitmap"))
{
formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
}
be_clipboard->Unlock();
VbglR3ClipboardReportFormats(fClientId, formats);
break;
}
case B_QUIT_REQUESTED:
fExiting = true;
break;
default:
BHandler::MessageReceived(message);
}
}