status_t AddFolders(BObjectList<IMAPFolder>& folders)
{
IMAPConnectionWorker::MailboxMap::iterator iterator
= fWorker.fMailboxes.begin();
for (; iterator != fWorker.fMailboxes.end(); iterator++) {
IMAPFolder* folder = iterator->first;
if (!folders.AddItem(folder))
return B_NO_MEMORY;
}
return B_OK;
}
bool
Model::ThreadWaitObjectGroup::GetThreadWaitObjects(
BObjectList<ThreadWaitObject>& objects)
{
ThreadWaitObjectList::Iterator it = fWaitObjects.GetIterator();
while (ThreadWaitObject* object = it.Next()) {
if (!objects.AddItem(object))
return false;
}
return true;
}
void
TokenizeToList(const char *string, BObjectList<BString> &stringList)
{
if (!string)
return;
char *workstr = strdup(string);
strtok(workstr, "\n");
char *token = strtok(NULL,"\n");
char *lasttoken = workstr;
if (!token)
{
free(workstr);
stringList.AddItem(new BString(string));
return;
}
int32 length = 0;
BString *newword = NULL;
while (token)
{
length = token - lasttoken;
newword = new BString(lasttoken, length + 1);
lasttoken = token;
stringList.AddItem(newword);
token = strtok(NULL,"\n");
}
length = strlen(lasttoken);
newword = new BString(lasttoken, length + 1);
lasttoken = token;
stringList.AddItem(newword);
free(workstr);
}
void
Team::GetWatchpointsInAddressRange(TargetAddressRange range,
BObjectList<Watchpoint>& watchpoints) const
{
int32 index = fWatchpoints.FindBinaryInsertionIndex(
WatchpointByAddressPredicate(range.Start()));
for (; Watchpoint* watchpoint = fWatchpoints.ItemAt(index); index++) {
if (watchpoint->Address() > range.End())
break;
watchpoints.AddItem(watchpoint);
}
}
BObjectList<Task>* TaskFS::GetTasks(TaskList forList)
{
Task *tmpTask = NULL;
BObjectList<Task> *taskTaskList = new BObjectList<Task>();
int32 i;
//grab a up to date List of Items
GetTasks();
for (i = 0; i<tasks->CountItems();i++) {
tmpTask=tasks->ItemAt(i);
if (*(tmpTask->GetTaskList()) == forList)
taskTaskList->AddItem(tmpTask);
}
return taskTaskList;
}
status_t
ModuleManager::_GetAddOn(const char *name, ModuleAddOn **_addon)
{
// search list first
for (int32 i = 0; ModuleAddOn *addon = fAddOns.ItemAt(i); i++) {
BString addonName(addon->Name());
addonName << "/";
if (!strcmp(name, addon->Name())
|| !strncmp(addonName.String(), name, addonName.Length())) {
addon->Get();
*_addon = addon;
return B_OK;
}
}
// not in list yet, load from disk
// iterate through module dirs
for (int32 i = 0; gModuleDirs[i]; i++) {
BPath path;
if (path.SetTo(gModuleDirs[i]) == B_OK
&& path.SetTo(path.Path(), name) == B_OK) {
BEntry entry;
for (;;) {
if (entry.SetTo(path.Path()) == B_OK && entry.Exists()) {
// found an entry: if it is a file, try to load it
if (entry.IsFile()) {
ModuleAddOn *addon = new ModuleAddOn;
if (addon->Load(path.Path(), gModuleDirs[i]) == B_OK) {
status_t status = addon->Get();
if (status < B_OK) {
delete addon;
return status;
}
fAddOns.AddItem(addon);
*_addon = addon;
return B_OK;
}
delete addon;
}
break;
}
// chop off last path component
if (path.GetParent(&path) != B_OK)
break;
}
}
}
return B_ENTRY_NOT_FOUND;
}
status_t
DebugReportGenerator::_DumpRunningThreads(BFile& _output)
{
AutoLocker< ::Team> locker(fTeam);
BString data("\nActive Threads:\n");
WRITE_AND_CHECK(_output, data);
BObjectList< ::Thread> threads;
::Thread* thread;
for (ThreadList::ConstIterator it = fTeam->Threads().GetIterator();
(thread = it.Next());) {
threads.AddItem(thread);
}
threads.SortItems(&_CompareThreads);
for (int32 i = 0; (thread = threads.ItemAt(i)) != NULL; i++) {
try {
data.SetToFormat("\tthread %" B_PRId32 ": %s %s\n", thread->ID(),
thread->Name(), thread->IsMainThread()
? "(main)" : "");
WRITE_AND_CHECK(_output, data);
if (thread->State() == THREAD_STATE_STOPPED) {
data.SetToFormat("\t\tstate: %s",
UiUtils::ThreadStateToString(thread->State(),
thread->StoppedReason()));
const BString& stoppedInfo = thread->StoppedReasonInfo();
if (stoppedInfo.Length() != 0)
data << " (" << stoppedInfo << ")";
data << "\n\n";
WRITE_AND_CHECK(_output, data);
// we need to release our lock on the team here
// since we might need to block and wait
// on the stack trace.
BReference< ::Thread> threadRef(thread);
locker.Unlock();
status_t error = _DumpDebuggedThreadInfo(_output, thread);
if (error != B_OK)
return error;
locker.Lock();
}
} catch (...) {
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
DebuggerInterface::GetImageInfos(BObjectList<ImageInfo>& infos)
{
// get the team's images
image_info imageInfo;
int32 cookie = 0;
while (get_next_image_info(fTeamID, &cookie, &imageInfo) == B_OK) {
ImageInfo* info = new(std::nothrow) ImageInfo(fTeamID, imageInfo.id,
imageInfo.name, imageInfo.type, (addr_t)imageInfo.text,
imageInfo.text_size, (addr_t)imageInfo.data, imageInfo.data_size);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
}
// Also add the "commpage" image, which belongs to the kernel, but is used
// by userland teams.
cookie = 0;
while (get_next_image_info(B_SYSTEM_TEAM, &cookie, &imageInfo) == B_OK) {
if ((addr_t)imageInfo.text >= USER_COMMPAGE_ADDR
&& (addr_t)imageInfo.text < USER_COMMPAGE_ADDR + COMMPAGE_SIZE) {
ImageInfo* info = new(std::nothrow) ImageInfo(B_SYSTEM_TEAM,
imageInfo.id, imageInfo.name, imageInfo.type,
(addr_t)imageInfo.text, imageInfo.text_size,
(addr_t)imageInfo.data, imageInfo.data_size);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
break;
}
}
return B_OK;
}
void
View::FindViews(uint32 flags, BObjectList<View>& list, int32& left)
{
if ((Flags() & flags) == flags) {
list.AddItem(this);
left--;
return;
}
for (View* child = FirstChild(); child; child = child->NextSibling()) {
child->FindViews(flags, list, left);
if (left == 0)
break;
}
}
status_t
LocalDebuggerInterface::GetThreadInfos(BObjectList<ThreadInfo>& infos)
{
thread_info threadInfo;
int32 cookie = 0;
while (get_next_thread_info(fTeamID, &cookie, &threadInfo) == B_OK) {
ThreadInfo* info = new(std::nothrow) ThreadInfo(threadInfo.team,
threadInfo.thread, threadInfo.name);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
LocalDebuggerInterface::GetSemaphoreInfos(BObjectList<SemaphoreInfo>& infos)
{
// get the team's semaphores
sem_info semInfo;
int32 cookie = 0;
while (get_next_sem_info(fTeamID, &cookie, &semInfo) == B_OK) {
SemaphoreInfo* info = new(std::nothrow) SemaphoreInfo(fTeamID,
semInfo.sem, semInfo.name, semInfo.count, semInfo.latest_holder);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
DebugReportGenerator::_DumpLoadedImages(BFile& _output)
{
AutoLocker< ::Team> locker(fTeam);
BString data("\nLoaded Images:\n");
WRITE_AND_CHECK(_output, data);
BObjectList<Image> images;
for (ImageList::ConstIterator it = fTeam->Images().GetIterator();
Image* image = it.Next();) {
images.AddItem(image);
}
images.SortItems(&_CompareImages);
Image* image = NULL;
data.SetToFormat("\tID\t\tText Base\tText End\tData Base\tData"
" End\tType\tName\n\t");
WRITE_AND_CHECK(_output, data);
data.Truncate(0L);
data.Append('-', 80);
data.Append("\n");
WRITE_AND_CHECK(_output, data);
for (int32 i = 0; (image = images.ItemAt(i)) != NULL; i++) {
const ImageInfo& info = image->Info();
char buffer[32];
try {
target_addr_t textBase = info.TextBase();
target_addr_t dataBase = info.DataBase();
data.SetToFormat("\t%" B_PRId32 "\t0x%08" B_PRIx64 "\t"
"0x%08" B_PRIx64 "\t0x%08" B_PRIx64 "\t0x%08" B_PRIx64 "\t"
"%-7s\t%s\n", info.ImageID(), textBase, textBase + info.TextSize(),
dataBase, dataBase + info.DataSize(),
UiUtils::ImageTypeToString(info.Type(), buffer,
sizeof(buffer)), info.Name().String());
WRITE_AND_CHECK(_output, data);
} catch (...) {
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
LocalDebuggerInterface::GetImageInfos(BObjectList<ImageInfo>& infos)
{
// get the team's images
image_info imageInfo;
int32 cookie = 0;
while (get_next_image_info(fTeamID, &cookie, &imageInfo) == B_OK) {
ImageInfo* info = new(std::nothrow) ImageInfo(fTeamID, imageInfo.id,
imageInfo.name, imageInfo.type, (addr_t)imageInfo.text,
imageInfo.text_size, (addr_t)imageInfo.data, imageInfo.data_size);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
LocalDebuggerInterface::GetAreaInfos(BObjectList<AreaInfo>& infos)
{
// get the team's areas
area_info areaInfo;
ssize_t cookie = 0;
while (get_next_area_info(fTeamID, &cookie, &areaInfo) == B_OK) {
AreaInfo* info = new(std::nothrow) AreaInfo(fTeamID, areaInfo.area,
areaInfo.name, (addr_t)areaInfo.address, areaInfo.size,
areaInfo.ram_size, areaInfo.lock, areaInfo.protection);
if (info == NULL || !infos.AddItem(info)) {
delete info;
return B_NO_MEMORY;
}
}
return B_OK;
}
status_t
LocalDebuggerInterface::GetSymbolInfos(team_id team, image_id image,
BObjectList<SymbolInfo>& infos)
{
// create a lookup context
debug_symbol_lookup_context* lookupContext;
status_t error = debug_create_symbol_lookup_context(team, image,
&lookupContext);
if (error != B_OK)
return error;
// create a symbol iterator
debug_symbol_iterator* iterator;
error = debug_create_image_symbol_iterator(
lookupContext, image, &iterator);
if (error != B_OK) {
debug_delete_symbol_lookup_context(lookupContext);
return error;
}
// get the symbols
char name[1024];
int32 type;
void* address;
size_t size;
while (debug_next_image_symbol(iterator, name, sizeof(name), &type,
&address, &size) == B_OK) {
SymbolInfo* info = new(std::nothrow) SymbolInfo(
(target_addr_t)(addr_t)address, size, type, name);
if (info == NULL)
break;
if (!infos.AddItem(info)) {
delete info;
break;
}
}
// delete the symbol iterator and lookup context
debug_delete_symbol_iterator(iterator);
debug_delete_symbol_lookup_context(lookupContext);
return B_OK;
}
void
Team::GetBreakpointsInAddressRange(TargetAddressRange range,
BObjectList<UserBreakpoint>& breakpoints) const
{
int32 index = fBreakpoints.FindBinaryInsertionIndex(
BreakpointByAddressPredicate(range.Start()));
for (; Breakpoint* breakpoint = fBreakpoints.ItemAt(index); index++) {
if (breakpoint->Address() > range.End())
break;
for (UserBreakpointInstanceList::ConstIterator it
= breakpoint->UserBreakpoints().GetIterator();
UserBreakpointInstance* instance = it.Next();) {
breakpoints.AddItem(instance->GetUserBreakpoint());
}
}
// TODO: Avoid duplicates!
}
status_t
WPASupplicantApp::_StartWatchingInterfaceChanges(
const wpa_supplicant *interface, StateChangeCallback callback, void *data)
{
StateChangeWatchingEntry *entry
= new(std::nothrow) StateChangeWatchingEntry(interface, callback, data);
if (entry == NULL)
return B_NO_MEMORY;
if (!fWatchingEntryListLocker.Lock()) {
delete entry;
return B_ERROR;
}
status_t result = B_OK;
if (!fWatchingEntryList.AddItem(entry)) {
result = B_ERROR;
delete entry;
}
fWatchingEntryListLocker.Unlock();
return result;
}
status_t
DebuggerImageDebugInfo::GetFunctions(BObjectList<FunctionDebugInfo>& functions)
{
BObjectList<SymbolInfo> symbols(20, true);
status_t error = fDebuggerInterface->GetSymbolInfos(fImageInfo.TeamID(),
fImageInfo.ImageID(), symbols);
if (error != B_OK)
return error;
// sort the symbols -- not necessary, but a courtesy to ImageDebugInfo which
// will peform better when inserting functions at the end of a list
symbols.SortItems(&_CompareSymbols);
// create the function infos
int32 functionsAdded = 0;
for (int32 i = 0; SymbolInfo* symbol = symbols.ItemAt(i); i++) {
if (symbol->Type() != B_SYMBOL_TYPE_TEXT)
continue;
FunctionDebugInfo* function = new(std::nothrow) BasicFunctionDebugInfo(
this, symbol->Address(), symbol->Size(), symbol->Name(),
Demangler::Demangle(symbol->Name()));
if (function == NULL || !functions.AddItem(function)) {
delete function;
int32 index = functions.CountItems() - 1;
for (; functionsAdded >= 0; functionsAdded--, index--) {
function = functions.RemoveItemAt(index);
delete function;
}
return B_NO_MEMORY;
}
functionsAdded++;
}
return B_OK;
}
void
TTracker::CloseWindowAndChildren(const node_ref *node)
{
BDirectory dir(node);
if (dir.InitCheck() != B_OK)
return;
AutoLock<WindowList> lock(&fWindowList);
BObjectList<BContainerWindow> closeList;
// make a list of all windows to be closed
// count from end to beginning so we can remove items safely
for (int32 index = fWindowList.CountItems() - 1; index >= 0; index--) {
BContainerWindow *window = dynamic_cast<BContainerWindow *>
(fWindowList.ItemAt(index));
if (window && window->TargetModel()) {
BEntry wind_entry;
wind_entry.SetTo(window->TargetModel()->EntryRef());
if ((*window->TargetModel()->NodeRef() == *node)
|| dir.Contains(&wind_entry)) {
// ToDo:
// get rid of the Remove here, BContainerWindow::Quit does it
fWindowList.RemoveItemAt(index);
closeList.AddItem(window);
}
}
}
// now really close the windows
int32 numItems = closeList.CountItems();
for (int32 index = 0; index < numItems; index++) {
BContainerWindow *window = closeList.ItemAt(index);
window->PostMessage(B_CLOSE_REQUESTED);
}
}
void
BreakpointManager::_UpdateImageBreakpoints(Image* image, bool removeOnly)
{
AutoLocker<BLocker> installLocker(fLock);
AutoLocker<Team> teamLocker(fTeam);
// remove obsolete user breakpoint instances
BObjectList<Breakpoint> breakpointsToUpdate;
for (UserBreakpointList::ConstIterator it
= fTeam->UserBreakpoints().GetIterator();
UserBreakpoint* userBreakpoint = it.Next();) {
int32 instanceCount = userBreakpoint->CountInstances();
for (int32 i = instanceCount - 1; i >= 0; i--) {
UserBreakpointInstance* instance = userBreakpoint->InstanceAt(i);
Breakpoint* breakpoint = instance->GetBreakpoint();
if (breakpoint == NULL || breakpoint->GetImage() != image)
continue;
userBreakpoint->RemoveInstanceAt(i);
breakpoint->RemoveUserBreakpoint(instance);
if (!breakpointsToUpdate.AddItem(breakpoint)) {
_UpdateBreakpointInstallation(breakpoint);
if (breakpoint->IsUnused())
fTeam->RemoveBreakpoint(breakpoint);
}
delete instance;
}
}
// update breakpoints
teamLocker.Unlock();
for (int32 i = 0; Breakpoint* breakpoint = breakpointsToUpdate.ItemAt(i);
i++) {
_UpdateBreakpointInstallation(breakpoint);
}
teamLocker.Lock();
for (int32 i = 0; Breakpoint* breakpoint = breakpointsToUpdate.ItemAt(i);
i++) {
if (breakpoint->IsUnused())
fTeam->RemoveBreakpoint(breakpoint);
}
// add breakpoint instances for function instances in the image (if we have
// an image debug info)
BObjectList<UserBreakpointInstance> newInstances;
ImageDebugInfo* imageDebugInfo = image->GetImageDebugInfo();
if (imageDebugInfo == NULL)
return;
for (UserBreakpointList::ConstIterator it
= fTeam->UserBreakpoints().GetIterator();
UserBreakpoint* userBreakpoint = it.Next();) {
// get the function
Function* function = fTeam->FunctionByID(
userBreakpoint->Location().GetFunctionID());
if (function == NULL)
continue;
const SourceLocation& sourceLocation
= userBreakpoint->Location().GetSourceLocation();
target_addr_t relativeAddress
= userBreakpoint->Location().RelativeAddress();
// iterate through the function instances
for (FunctionInstanceList::ConstIterator it
= function->Instances().GetIterator();
FunctionInstance* functionInstance = it.Next();) {
if (functionInstance->GetImageDebugInfo() != imageDebugInfo)
continue;
// get the breakpoint address for the instance
target_addr_t instanceAddress = 0;
if (functionInstance->SourceFile() != NULL) {
// We have a source file, so get the address for the source
// location.
Statement* statement = NULL;
FunctionDebugInfo* functionDebugInfo
= functionInstance->GetFunctionDebugInfo();
functionDebugInfo->GetSpecificImageDebugInfo()
->GetStatementAtSourceLocation(functionDebugInfo,
sourceLocation, statement);
if (statement != NULL) {
instanceAddress = statement->CoveringAddressRange().Start();
// TODO: What about BreakpointAllowed()?
statement->ReleaseReference();
// TODO: Make sure we do hit the function in question!
}
}
if (instanceAddress == 0) {
// No source file (or we failed getting the statement), so try
// to use the same relative address.
if (relativeAddress > functionInstance->Size())
continue;
instanceAddress = functionInstance->Address() + relativeAddress;
// TODO: Make sure it does at least hit an instruction!
}
// create the user breakpoint instance
UserBreakpointInstance* instance = new(std::nothrow)
UserBreakpointInstance(userBreakpoint, instanceAddress);
if (instance == NULL || !newInstances.AddItem(instance)) {
delete instance;
continue;
}
if (!userBreakpoint->AddInstance(instance)) {
newInstances.RemoveItemAt(newInstances.CountItems() - 1);
delete instance;
}
// get/create the breakpoint for the address
target_addr_t address = instance->Address();
Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);
if (breakpoint == NULL) {
breakpoint = new(std::nothrow) Breakpoint(image, address);
if (breakpoint == NULL || !fTeam->AddBreakpoint(breakpoint)) {
delete breakpoint;
break;
}
}
breakpoint->AddUserBreakpoint(instance);
instance->SetBreakpoint(breakpoint);
}
}
// install the breakpoints for the new user breakpoint instances
teamLocker.Unlock();
for (int32 i = 0; UserBreakpointInstance* instance = newInstances.ItemAt(i);
i++) {
Breakpoint* breakpoint = instance->GetBreakpoint();
if (breakpoint == NULL
|| _UpdateBreakpointInstallation(breakpoint) != B_OK) {
// something went wrong -- remove the instance
teamLocker.Lock();
instance->GetUserBreakpoint()->RemoveInstance(instance);
if (breakpoint != NULL) {
breakpoint->AddUserBreakpoint(instance);
if (breakpoint->IsUnused())
fTeam->RemoveBreakpoint(breakpoint);
}
teamLocker.Unlock();
}
}
}
bool
BPoseView::DeleteProperty(BMessage *_SCRIPTING_ONLY(specifier),
int32 _SCRIPTING_ONLY(form), const char *_SCRIPTING_ONLY(property),
BMessage *_SCRIPTING_ONLY(reply))
{
#if _SUPPORTS_FEATURE_SCRIPTING
status_t error = B_OK;
bool handled = false;
if (strcmp(property, kPropertySelection) == 0) {
// deleting on a selection is handled as removing a part of the selection
// not to be confused with deleting a selected item
if (form == (int32)B_ENTRY_SPECIFIER) {
entry_ref ref;
// select poses specified by entries
for (int32 index = 0; specifier->FindRef("refs", index, &ref)
== B_OK; index++) {
int32 poseIndex;
BPose *pose = FindPose(&ref, form, &poseIndex);
if (!pose) {
error = B_ENTRY_NOT_FOUND;
break;
}
RemovePoseFromSelection(pose);
}
handled = true;
} else if (form == B_INDEX_SPECIFIER) {
// move all poses specified by index to Trash
int32 specifyingIndex;
for (int32 index = 0; specifier->FindInt32("index", index,
&specifyingIndex) == B_OK; index++) {
BPose *pose = PoseAtIndex(specifyingIndex);
if (!pose) {
error = B_BAD_INDEX;
break;
}
RemovePoseFromSelection(pose);
}
handled = true;
} else
return false;
} else if (strcmp(property, kPropertyEntry) == 0) {
// deleting entries is handled by moving entries to trash
// build a list of entries, specified by the specifier
BObjectList<entry_ref> *entryList = new BObjectList<entry_ref>();
// list will be deleted for us by the trashing thread
if (form == (int32)B_ENTRY_SPECIFIER) {
// move all poses specified by entry_ref to Trash
entry_ref ref;
for (int32 index = 0; specifier->FindRef("refs", index, &ref)
== B_OK; index++)
entryList->AddItem(new entry_ref(ref));
} else if (form == (int32)B_INDEX_SPECIFIER) {
// move all poses specified by index to Trash
int32 specifyingIndex;
for (int32 index = 0; specifier->FindInt32("index", index, &specifyingIndex)
== B_OK; index++) {
BPose *pose = PoseAtIndex(specifyingIndex);
if (!pose) {
error = B_BAD_INDEX;
break;
}
entryList->AddItem(new entry_ref(*pose->TargetModel()->EntryRef()));
}
} else
return false;
if (error == B_OK) {
TrackerSettings settings;
if (!settings.DontMoveFilesToTrash()) {
// move the list we build into trash, don't make the trashing task
// select the next item
MoveListToTrash(entryList, false, false);
} else
Delete(entryList, false, settings.AskBeforeDeleteFile());
}
handled = true;
}
if (error != B_OK)
reply->AddInt32("error", error);
return handled;
#else
return false;
#endif
}
status_t
DwarfImageDebugInfo::GetFunctions(const BObjectList<SymbolInfo>& symbols,
BObjectList<FunctionDebugInfo>& functions)
{
TRACE_IMAGES("DwarfImageDebugInfo::GetFunctions()\n");
TRACE_IMAGES(" %" B_PRId32 " compilation units\n",
fFile->CountCompilationUnits());
for (int32 i = 0; CompilationUnit* unit = fFile->CompilationUnitAt(i);
i++) {
DIECompileUnitBase* unitEntry = unit->UnitEntry();
// printf(" %s:\n", unitEntry->Name());
// printf(" address ranges:\n");
// TargetAddressRangeList* rangeList = unitEntry->AddressRanges();
// if (rangeList != NULL) {
// int32 count = rangeList->CountRanges();
// for (int32 i = 0; i < count; i++) {
// TargetAddressRange range = rangeList->RangeAt(i);
// printf(" %#llx - %#llx\n", range.Start(), range.End());
// }
// } else {
// printf(" %#llx - %#llx\n", (target_addr_t)unitEntry->LowPC(),
// (target_addr_t)unitEntry->HighPC());
// }
// printf(" functions:\n");
for (DebugInfoEntryList::ConstIterator it
= unitEntry->OtherChildren().GetIterator();
DebugInfoEntry* entry = it.Next();) {
if (entry->Tag() != DW_TAG_subprogram)
continue;
DIESubprogram* subprogramEntry = static_cast<DIESubprogram*>(entry);
// ignore declarations and inlined functions
if (subprogramEntry->IsDeclaration()
|| subprogramEntry->Inline() == DW_INL_inlined
|| subprogramEntry->Inline() == DW_INL_declared_inlined) {
continue;
}
// get the name
BString name;
DwarfUtils::GetFullyQualifiedDIEName(subprogramEntry, name);
if (name.Length() == 0)
continue;
// get the address ranges
TargetAddressRangeList* rangeList = fFile->ResolveRangeList(unit,
subprogramEntry->AddressRangesOffset());
if (rangeList == NULL) {
target_addr_t lowPC = subprogramEntry->LowPC();
target_addr_t highPC = subprogramEntry->HighPC();
if (highPC <= lowPC)
continue;
rangeList = new(std::nothrow) TargetAddressRangeList(
TargetAddressRange(lowPC, highPC - lowPC));
if (rangeList == NULL)
return B_NO_MEMORY;
// TODO: Clean up already added functions!
}
BReference<TargetAddressRangeList> rangeListReference(rangeList,
true);
// get the source location
const char* directoryPath = NULL;
const char* fileName = NULL;
int32 line = -1;
int32 column = -1;
DwarfUtils::GetDeclarationLocation(fFile, subprogramEntry,
directoryPath, fileName, line, column);
LocatableFile* file = NULL;
if (fileName != NULL) {
file = fFileManager->GetSourceFile(directoryPath,
fileName);
}
BReference<LocatableFile> fileReference(file, true);
// create and add the functions
DwarfFunctionDebugInfo* function
= new(std::nothrow) DwarfFunctionDebugInfo(this, unit,
subprogramEntry, rangeList, name, file,
SourceLocation(line, std::max(column, (int32)0)));
if (function == NULL || !functions.AddItem(function)) {
delete function;
return B_NO_MEMORY;
// TODO: Clean up already added functions!
}
// BString name;
// DwarfUtils::GetFullyQualifiedDIEName(subprogramEntry, name);
// printf(" subprogram entry: %p, name: %s, declaration: %d\n",
// subprogramEntry, name.String(),
// subprogramEntry->IsDeclaration());
//
// rangeList = subprogramEntry->AddressRanges();
// if (rangeList != NULL) {
// int32 count = rangeList->CountRanges();
// for (int32 i = 0; i < count; i++) {
// TargetAddressRange range = rangeList->RangeAt(i);
// printf(" %#llx - %#llx\n", range.Start(), range.End());
// }
// } else {
// printf(" %#llx - %#llx\n",
// (target_addr_t)subprogramEntry->LowPC(),
// (target_addr_t)subprogramEntry->HighPC());
// }
}
}
if (fFile->CountCompilationUnits() != 0)
return B_OK;
// if we had no compilation units, fall back to providing basic
// debug infos with DWARF-supported call frame unwinding,
// if available.
if (fFile->HasFrameInformation()) {
return SpecificImageDebugInfo::GetFunctionsFromSymbols(symbols,
functions, fDebuggerInterface, fImageInfo, this);
}
return B_OK;
}
THeaderView::THeaderView(BRect rect, BRect windowRect, bool incoming,
bool resending, uint32 defaultCharacterSet, int32 defaultAccount)
:
BBox(rect, "m_header", B_FOLLOW_LEFT_RIGHT, B_WILL_DRAW, B_NO_BORDER),
fAccountMenu(NULL),
fEncodingMenu(NULL),
fAccountID(defaultAccount),
fAccountTo(NULL),
fAccount(NULL),
fBcc(NULL),
fCc(NULL),
fSubject(NULL),
fTo(NULL),
fDateLabel(NULL),
fDate(NULL),
fIncoming(incoming),
fCharacterSetUserSees(defaultCharacterSet),
fResending(resending),
fBccMenu(NULL),
fCcMenu(NULL),
fToMenu(NULL),
fEmailList(NULL)
{
BMenuField* field;
BMessage* msg;
BString kAttachments(B_TRANSLATE("Attachments: "));
BString kDecoding(B_TRANSLATE("Decoding:"));
BString kFrom(B_TRANSLATE("From:"));
BString kTo(B_TRANSLATE("To:"));
BString kEncoding(B_TRANSLATE("Encoding:"));
BString kAccount(B_TRANSLATE("Account:"));
BString kCc(B_TRANSLATE("Cc:"));
BString kSubject(B_TRANSLATE("Subject:"));
BString kBcc(B_TRANSLATE("Bcc:"));
BObjectList<BString> kToCompare;
kToCompare.AddItem(&kAttachments);
kToCompare.AddItem(&kDecoding);
kToCompare.AddItem(&kFrom);
kToCompare.AddItem(&kTo);
kToCompare.AddItem(&kEncoding);
kToCompare.AddItem(&kAccount);
kToCompare.AddItem(&kCc);
kToCompare.AddItem(&kSubject);
kToCompare.AddItem(&kBcc);
float x = 0;
// Get the longest translated string's width to use when calculating
// horizontal positions
for(int i = 0; i < kToCompare.CountItems(); ++i) {
float stringWidth = StringWidth(kToCompare.ItemAt(i)->String()) + 9;
if (stringWidth > x)
x = stringWidth;
}
float y = TO_FIELD_V;
BMenuBar* dummy = new BMenuBar(BRect(0, 0, 100, 15), "Dummy");
AddChild(dummy);
float width, menuBarHeight;
dummy->GetPreferredSize(&width, &menuBarHeight);
dummy->RemoveSelf();
delete dummy;
float menuFieldHeight = menuBarHeight + 2;
float controlHeight = menuBarHeight + floorf(be_plain_font->Size() / 1.15);
if (!fIncoming) {
InitEmailCompletion();
InitGroupCompletion();
}
// Prepare the character set selection pop-up menu (we tell the user that
// it is the Encoding menu, even though it is really the character set).
// It may appear in the first line, to the right of the From box if the
// user is reading an e-mail. It appears on the second line, to the right
// of the e-mail account menu, if the user is composing a message. It lets
// the user quickly select a character set different from the application
// wide default one, and also shows them which character set is active. If
// you are reading a message, you also see an item that says "Automatic"
// for automatic decoding character set choice. It can slide around as the
// window is resized when viewing a message, but not when composing
// (because the adjacent pop-up menu can't resize dynamically due to a BeOS
// bug).
float widestCharacterSet = 0;
bool markedCharSet = false;
BMenuItem* item;
fEncodingMenu = new BPopUpMenu(B_EMPTY_STRING);
BCharacterSetRoster roster;
BCharacterSet charset;
while (roster.GetNextCharacterSet(&charset) == B_OK) {
BString name(charset.GetPrintName());
const char* mime = charset.GetMIMEName();
if (mime)
name << " (" << mime << ")";
uint32 convertID;
if (mime == NULL || strcasecmp(mime, "UTF-8") != 0)
convertID = charset.GetConversionID();
else
convertID = B_MAIL_UTF8_CONVERSION;
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", convertID);
fEncodingMenu->AddItem(item = new BMenuItem(name.String(), msg));
if (convertID == fCharacterSetUserSees && !markedCharSet) {
item->SetMarked(true);
markedCharSet = true;
}
if (StringWidth(name.String()) > widestCharacterSet)
widestCharacterSet = StringWidth(name.String());
}
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", B_MAIL_US_ASCII_CONVERSION);
fEncodingMenu->AddItem(item = new BMenuItem("US-ASCII", msg));
if (fCharacterSetUserSees == B_MAIL_US_ASCII_CONVERSION && !markedCharSet) {
item->SetMarked(true);
markedCharSet = true;
}
if (!resending && fIncoming) {
// reading a message, display the Automatic item
fEncodingMenu->AddSeparatorItem();
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", B_MAIL_NULL_CONVERSION);
fEncodingMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Automatic"), msg));
if (!markedCharSet)
item->SetMarked(true);
}
// First line of the header, From for reading e-mails (includes the
// character set choice at the right), To when composing (nothing else in
// the row).
BRect r;
char string[20];
if (fIncoming && !resending) {
// Set up the character set pop-up menu on the right of "To" box.
r.Set (windowRect.Width() - widestCharacterSet -
StringWidth (kDecoding.String()) - 2 * SEPARATOR_MARGIN,
y - 2, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
field = new BMenuField (r, "decoding", kDecoding.String(),
fEncodingMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
field->SetDivider(field->StringWidth(kDecoding.String()) + 5);
AddChild(field);
r.Set(SEPARATOR_MARGIN, y,
field->Frame().left - SEPARATOR_MARGIN, y + menuFieldHeight);
sprintf(string, kFrom.String());
} else {
r.Set(x - 12, y, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
string[0] = 0;
}
y += controlHeight;
fTo = new TTextControl(r, string, new BMessage(TO_FIELD), fIncoming,
resending, B_FOLLOW_LEFT_RIGHT);
fTo->SetFilter(mail_to_filter);
if (!fIncoming || resending) {
fTo->SetChoiceList(&fEmailList);
fTo->SetAutoComplete(true);
} else {
fTo->SetDivider(x - 12 - SEPARATOR_MARGIN);
fTo->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
}
AddChild(fTo);
msg = new BMessage(FIELD_CHANGED);
msg->AddInt32("bitmask", FIELD_TO);
fTo->SetModificationMessage(msg);
if (!fIncoming || resending) {
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
kTo.String()) + 25);
r.top -= 1;
fToMenu = new QPopupMenu(kTo.String());
field = new BMenuField(r, "", "", fToMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
}
// "From:" accounts Menu and Encoding Menu.
if (!fIncoming || resending) {
// Put the character set box on the right of the From field.
r.Set(windowRect.Width() - widestCharacterSet -
StringWidth(kEncoding.String()) - 2 * SEPARATOR_MARGIN,
y - 2, windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
BMenuField* encodingField = new BMenuField(r, "encoding",
kEncoding.String(), fEncodingMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
encodingField->SetDivider(encodingField->StringWidth(
kEncoding.String()) + 5);
AddChild(encodingField);
field = encodingField;
// And now the "from account" pop-up menu, on the left side, taking the
// remaining space.
fAccountMenu = new BPopUpMenu(B_EMPTY_STRING);
BMailAccounts accounts;
bool marked = false;
for (int32 i = 0; i < accounts.CountAccounts(); i++) {
BMailAccountSettings* account = accounts.AccountAt(i);
BString name = account->Name();
name << ": " << account->RealName() << " <"
<< account->ReturnAddress() << ">";
msg = new BMessage(kMsgFrom);
BMenuItem *item = new BMenuItem(name, msg);
msg->AddInt32("id", account->AccountID());
if (defaultAccount == account->AccountID()) {
item->SetMarked(true);
marked = true;
}
fAccountMenu->AddItem(item);
}
if (!marked) {
BMenuItem *item = fAccountMenu->ItemAt(0);
if (item != NULL) {
item->SetMarked(true);
fAccountID = item->Message()->FindInt32("id");
} else {
fAccountMenu->AddItem(
item = new BMenuItem(B_TRANSLATE("<none>"), NULL));
item->SetEnabled(false);
fAccountID = ~(int32)0;
}
// default account is invalid, set to marked
// TODO: do this differently, no casting and knowledge
// of TMailApp here....
if (TMailApp* app = dynamic_cast<TMailApp*>(be_app))
app->SetDefaultAccount(fAccountID);
}
r.Set(SEPARATOR_MARGIN, y - 2,
field->Frame().left - SEPARATOR_MARGIN, y + menuFieldHeight);
field = new BMenuField(r, "account", kFrom.String(),
fAccountMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_LEFT_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
AddChild(field, encodingField);
field->SetDivider(x - 12 - SEPARATOR_MARGIN + kMenuFieldDividerOffset);
field->SetAlignment(B_ALIGN_RIGHT);
y += controlHeight;
} else {
// To: account
bool account = BMailAccounts().CountAccounts() > 0;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
if (account)
r.right -= SEPARATOR_MARGIN + ACCOUNT_FIELD_WIDTH;
fAccountTo = new TTextControl(r, kTo.String(), NULL, fIncoming,
false, B_FOLLOW_LEFT_RIGHT);
fAccountTo->SetEnabled(false);
fAccountTo->SetDivider(x - 12 - SEPARATOR_MARGIN);
fAccountTo->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
AddChild(fAccountTo);
if (account) {
r.left = r.right + 6; r.right = windowRect.Width() - SEPARATOR_MARGIN;
fAccount = new TTextControl(r, kAccount.String(), NULL,
fIncoming, false, B_FOLLOW_RIGHT | B_FOLLOW_TOP);
fAccount->SetEnabled(false);
AddChild(fAccount);
}
y += controlHeight;
}
if (fIncoming) {
--y;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fCc = new TTextControl(r, kCc.String(),
NULL, fIncoming, false, B_FOLLOW_LEFT_RIGHT);
fCc->SetEnabled(false);
fCc->SetDivider(x - 12 - SEPARATOR_MARGIN);
fCc->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
AddChild(fCc);
}
--y;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fSubject = new TTextControl(r, kSubject.String(),
new BMessage(SUBJECT_FIELD),fIncoming, false, B_FOLLOW_LEFT_RIGHT);
AddChild(fSubject);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_SUBJECT);
fSubject->SetModificationMessage(msg);
fSubject->SetDivider(x - 12 - SEPARATOR_MARGIN);
fSubject->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
if (fResending)
fSubject->SetEnabled(false);
--y;
if (!fIncoming) {
r.Set(x - 12, y, CC_FIELD_H + CC_FIELD_WIDTH, y + menuFieldHeight);
fCc = new TTextControl(r, "", new BMessage(CC_FIELD), fIncoming, false);
fCc->SetFilter(mail_to_filter);
fCc->SetChoiceList(&fEmailList);
fCc->SetAutoComplete(true);
AddChild(fCc);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_CC);
fCc->SetModificationMessage(msg);
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
kCc.String()) + 25);
r.top -= 1;
fCcMenu = new QPopupMenu(kCc.String());
field = new BMenuField(r, "", "", fCcMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
r.Set(BCC_FIELD_H + be_plain_font->StringWidth(kBcc.String()), y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fBcc = new TTextControl(r, "", new BMessage(BCC_FIELD),
fIncoming, false, B_FOLLOW_LEFT_RIGHT);
fBcc->SetFilter(mail_to_filter);
fBcc->SetChoiceList(&fEmailList);
fBcc->SetAutoComplete(true);
AddChild(fBcc);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_BCC);
fBcc->SetModificationMessage(msg);
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
kBcc.String()) + 25);
r.top -= 1;
fBccMenu = new QPopupMenu(kBcc.String());
field = new BMenuField(r, "", "", fBccMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
} else {
y -= SEPARATOR_MARGIN;
r.Set(SEPARATOR_MARGIN, y, x - 12 - 1, y + menuFieldHeight);
fDateLabel = new BStringView(r, "", kDateLabel);
fDateLabel->SetAlignment(B_ALIGN_RIGHT);
AddChild(fDateLabel);
fDateLabel->SetHighColor(0, 0, 0);
r.Set(r.right + 9, y, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
fDate = new BStringView(r, "", "");
AddChild(fDate);
fDate->SetHighColor(0, 0, 0);
y += controlHeight + 5;
}
ResizeTo(Bounds().Width(), y);
}
bool
FSClipboardPaste(Model *model, uint32 linksMode)
{
if (!FSClipboardHasRefs())
return false;
BMessenger tracker(kTrackerSignature);
node_ref *destNodeRef = (node_ref *)model->NodeRef();
// these will be passed to the asynchronous copy/move process
BObjectList<entry_ref> *moveList = new BObjectList<entry_ref>(0, true);
BObjectList<entry_ref> *copyList = new BObjectList<entry_ref>(0, true);
if ((be_clipboard->Lock())) {
BMessage *clip = be_clipboard->Data();
if (clip != NULL) {
char modeName[64];
uint32 moveMode = 0;
BMessage *updateMessage = NULL;
node_ref updateNodeRef;
updateNodeRef.device = -1;
char *refName;
type_code type;
int32 count;
for (int32 index = 0; clip->GetInfo(B_REF_TYPE, index,
#ifdef B_BEOS_VERSION_DANO
(const char **)
#endif
&refName, &type, &count) == B_OK; index++) {
entry_ref ref;
if (clip->FindRef(refName, &ref) != B_OK)
continue;
// If the entry_ref's directory has changed, send previous notification
// (if any), and start new one for the new directory
if (updateNodeRef.device != ref.device
|| updateNodeRef.node != ref.directory) {
if (updateMessage != NULL) {
tracker.SendMessage(updateMessage);
delete updateMessage;
}
updateNodeRef.device = ref.device;
updateNodeRef.node = ref.directory;
updateMessage = new BMessage(kFSClipboardChanges);
updateMessage->AddInt32("device", updateNodeRef.device);
updateMessage->AddInt64("directory", updateNodeRef.node);
}
// we need this data later on
MakeModeNameFromRefName(modeName, refName);
if (!linksMode && clip->FindInt32(modeName, (int32 *)&moveMode) != B_OK)
continue;
BEntry entry(&ref);
uint32 newMoveMode = 0;
bool sameDirectory = destNodeRef->device == ref.device && destNodeRef->node == ref.directory;
if (!entry.Exists()) {
// The entry doesn't exist anymore, so we'll remove
// that entry from the clipboard as well
clip->RemoveName(refName);
clip->RemoveName(modeName);
newMoveMode = kDelete;
} else {
// the entry does exist, so lets see what we will
// do with it
if (!sameDirectory) {
if (linksMode || moveMode == kMoveSelectionTo) {
// the linksMode uses the moveList as well
moveList->AddItem(new entry_ref(ref));
} else if (moveMode == kCopySelectionTo)
copyList->AddItem(new entry_ref(ref));
}
// if the entry should have been removed from its directory,
// we want to copy that entry next time, no matter if the
// items don't have to be moved at all (source == target)
if (moveMode == kMoveSelectionTo)
newMoveMode = kCopySelectionTo;
}
// add the change to the update message (if necessary)
if (newMoveMode) {
clip->ReplaceInt32(modeName, kCopySelectionTo);
TClipboardNodeRef clipNode;
MakeNodeFromName(&clipNode.node, modeName);
clipNode.moveMode = kDelete;
updateMessage->AddData("tcnode", T_CLIPBOARD_NODE, &clipNode,
sizeof(TClipboardNodeRef), true);
}
}
be_clipboard->Commit();
// send notification for the last directory
if (updateMessage != NULL) {
tracker.SendMessage(updateMessage);
delete updateMessage;
}
}
be_clipboard->Unlock();
}
bool okToMove = true;
// can't copy/paste to root('/') directory
if (model->IsRoot()) {
(new BAlert("", kNoCopyToRootStr, "Cancel", NULL, NULL,
B_WIDTH_AS_USUAL, B_WARNING_ALERT))->Go();
okToMove = false;
}
BEntry entry;
model->GetEntry(&entry);
// can't copy items into the trash
if (copyList->CountItems() > 0 && FSIsTrashDir(&entry)) {
(new BAlert("", kNoCopyToTrashStr, "Cancel", NULL, NULL,
B_WIDTH_AS_USUAL, B_WARNING_ALERT))->Go();
okToMove = false;
}
if (!okToMove) {
// there was some problem with our target, so we bail out here
delete moveList;
delete copyList;
return false;
}
// asynchronous calls take over ownership of the objects passed to it
if (moveList->CountItems() > 0)
FSMoveToFolder(moveList, new BEntry(entry), linksMode ? linksMode : kMoveSelectionTo);
else
delete moveList;
if (copyList->CountItems() > 0)
FSMoveToFolder(copyList, new BEntry(entry), kCopySelectionTo);
else
delete copyList;
return true;
}
// ---------------------------------------------------------------
// AddTranslationItems
//
// Envious of that "Save As" menu in ShowImage? Well, you can have your own!
// AddTranslationItems will add menu items for all translations from the
// basic format you specify (B_TRANSLATOR_BITMAP, B_TRANSLATOR_TEXT etc).
// The translator ID and format constant chosen will be added to the message
// that is sent to you when the menu item is selected.
//
// The following code is a modified version of code
// written by Jon Watte from
// http://www.b500.com/bepage/TranslationKit2.html
//
// Preconditions:
//
// Parameters: intoMenu, the menu where the entries are created
// fromType, the type of translators to put on
// intoMenu
// kModel, the BMessage model for creating the menu
// if NULL, B_TRANSLATION_MENU is used
// kTranslationIdName, the name used for
// translator_id in the menuitem,
// if NULL, be:translator is used
// kTranslatorTypeName, the name used for
// output format id in the menuitem
// roster, BTranslatorRoster used to find translators
// if NULL, the default translators are used
//
//
// Postconditions:
//
// Returns: B_BAD_VALUE, if intoMenu is NULL
// B_OK, if successful
// error value if not successful
// ---------------------------------------------------------------
status_t
BTranslationUtils::AddTranslationItems(BMenu *intoMenu, uint32 fromType,
const BMessage *kModel, const char *kTranslatorIdName,
const char *kTranslatorTypeName, BTranslatorRoster *roster)
{
if (!intoMenu)
return B_BAD_VALUE;
if (!roster)
roster = BTranslatorRoster::Default();
if (!kTranslatorIdName)
kTranslatorIdName = "be:translator";
if (!kTranslatorTypeName)
kTranslatorTypeName = "be:type";
translator_id * ids = NULL;
int32 count = 0;
status_t err = roster->GetAllTranslators(&ids, &count);
if (err < B_OK)
return err;
BObjectList<translator_info> infoList;
for (int tix = 0; tix < count; tix++) {
const translation_format *formats = NULL;
int32 numFormats = 0;
bool ok = false;
err = roster->GetInputFormats(ids[tix], &formats, &numFormats);
if (err == B_OK) {
for (int iix = 0; iix < numFormats; iix++) {
if (formats[iix].type == fromType) {
ok = true;
break;
}
}
}
if (!ok)
continue;
// Get supported output formats
err = roster->GetOutputFormats(ids[tix], &formats, &numFormats);
if (err == B_OK) {
for (int oix = 0; oix < numFormats; oix++) {
if (formats[oix].type != fromType) {
infoList.AddItem(_BuildTranslatorInfo(ids[tix],
const_cast<translation_format*>(&formats[oix])));
}
}
}
}
// Sort alphabetically by name
infoList.SortItems(&_CompareTranslatorInfoByName);
// Now add the menu items
for (int i = 0; i < infoList.CountItems(); i++) {
translator_info* info = infoList.ItemAt(i);
BMessage *itemmsg;
if (kModel)
itemmsg = new BMessage(*kModel);
else
itemmsg = new BMessage(B_TRANSLATION_MENU);
itemmsg->AddInt32(kTranslatorIdName, info->translator);
itemmsg->AddInt32(kTranslatorTypeName, info->type);
intoMenu->AddItem(new BMenuItem(info->name, itemmsg));
// Delete object created in _BuildTranslatorInfo
delete info;
}
delete[] ids;
return B_OK;
}
status_t
TeamDebugInfo::AddImageDebugInfo(ImageDebugInfo* imageDebugInfo)
{
AutoLocker<BLocker> locker(fLock);
// We have both locks now, so that for read-only access either lock
// suffices.
if (!fImages.AddItem(imageDebugInfo))
return B_NO_MEMORY;
// Match all of the image debug info's functions instances with functions.
BObjectList<SourceFileEntry> sourceFileEntries;
for (int32 i = 0;
FunctionInstance* instance = imageDebugInfo->FunctionAt(i); i++) {
// lookup the function or create it, if it doesn't exist yet
Function* function = fFunctions->Lookup(instance);
if (function != NULL) {
// TODO: Also update possible user breakpoints in this function!
function->AddInstance(instance);
instance->SetFunction(function);
// The new image debug info might have additional information about
// the source file of the function, so remember the source file
// entry.
if (LocatableFile* sourceFile = function->SourceFile()) {
SourceFileEntry* entry = fSourceFiles->Lookup(sourceFile);
if (entry != NULL && entry->GetSourceCode() != NULL)
sourceFileEntries.AddItem(entry);
}
} else {
function = new(std::nothrow) Function;
if (function == NULL) {
RemoveImageDebugInfo(imageDebugInfo);
return B_NO_MEMORY;
}
function->AddInstance(instance);
instance->SetFunction(function);
status_t error = _AddFunction(function);
// Insert after adding the instance. Otherwise the function
// wouldn't be hashable/comparable.
if (error != B_OK) {
function->RemoveInstance(instance);
instance->SetFunction(NULL);
RemoveImageDebugInfo(imageDebugInfo);
return error;
}
}
}
// update the source files the image debug info knows about
for (int32 i = 0; SourceFileEntry* entry = sourceFileEntries.ItemAt(i);
i++) {
FileSourceCode* sourceCode = entry->GetSourceCode();
sourceCode->Lock();
if (imageDebugInfo->AddSourceCodeInfo(entry->SourceFile(),
sourceCode) == B_OK) {
// TODO: Notify interesting parties! Iterate through all functions
// for this source file?
}
sourceCode->Unlock();
}
return B_OK;
}
/*! \brief Initializes the bitmap.
\param bounds The bitmap dimensions.
\param colorSpace The bitmap's color space.
\param flags Creation flags.
\param bytesPerRow The number of bytes per row the bitmap should use.
\c B_ANY_BYTES_PER_ROW to let the constructor choose an appropriate
value.
\param screenID ???
*/
void
BBitmap::_InitObject(BRect bounds, color_space colorSpace, uint32 flags,
int32 bytesPerRow, screen_id screenID)
{
//printf("BBitmap::InitObject(bounds: BRect(%.1f, %.1f, %.1f, %.1f), format: %ld, flags: %ld, bpr: %ld\n",
// bounds.left, bounds.top, bounds.right, bounds.bottom, colorSpace, flags, bytesPerRow);
// TODO: Should we handle rounding of the "bounds" here? How does R5 behave?
status_t error = B_OK;
#ifdef RUN_WITHOUT_APP_SERVER
flags |= B_BITMAP_NO_SERVER_LINK;
#endif // RUN_WITHOUT_APP_SERVER
_CleanUp();
// check params
if (!bounds.IsValid() || !bitmaps_support_space(colorSpace, NULL)) {
error = B_BAD_VALUE;
} else {
// bounds is in floats and might be valid but much larger than what we
// can handle the size could not be expressed in int32
double realSize = bounds.Width() * bounds.Height();
if (realSize > (double)(INT_MAX / 4)) {
fprintf(stderr, "bitmap bounds is much too large: "
"BRect(%.1f, %.1f, %.1f, %.1f)\n",
bounds.left, bounds.top, bounds.right, bounds.bottom);
error = B_BAD_VALUE;
}
}
if (error == B_OK) {
int32 bpr = get_bytes_per_row(colorSpace, bounds.IntegerWidth() + 1);
if (bytesPerRow < 0)
bytesPerRow = bpr;
else if (bytesPerRow < bpr)
// NOTE: How does R5 behave?
error = B_BAD_VALUE;
}
// allocate the bitmap buffer
if (error == B_OK) {
// TODO: Let the app_server return the size when it allocated the bitmap
int32 size = bytesPerRow * (bounds.IntegerHeight() + 1);
if ((flags & B_BITMAP_NO_SERVER_LINK) != 0) {
fBasePointer = (uint8*)malloc(size);
if (fBasePointer) {
fSize = size;
fColorSpace = colorSpace;
fBounds = bounds;
fBytesPerRow = bytesPerRow;
fFlags = flags;
} else
error = B_NO_MEMORY;
} else {
// Ask the server (via our owning application) to create a bitmap.
BPrivate::AppServerLink link;
// Attach Data:
// 1) BRect bounds
// 2) color_space space
// 3) int32 bitmap_flags
// 4) int32 bytes_per_row
// 5) int32 screen_id::id
link.StartMessage(AS_CREATE_BITMAP);
link.Attach<BRect>(bounds);
link.Attach<color_space>(colorSpace);
link.Attach<uint32>(flags);
link.Attach<int32>(bytesPerRow);
link.Attach<int32>(screenID.id);
if (link.FlushWithReply(error) == B_OK && error == B_OK) {
// server side success
// Get token
link.Read<int32>(&fServerToken);
uint8 allocationFlags;
link.Read<uint8>(&allocationFlags);
link.Read<area_id>(&fServerArea);
link.Read<int32>(&fAreaOffset);
BPrivate::ServerMemoryAllocator* allocator
= BApplication::Private::ServerAllocator();
if ((allocationFlags & kNewAllocatorArea) != 0) {
error = allocator->AddArea(fServerArea, fArea,
fBasePointer, size);
} else {
error = allocator->AreaAndBaseFor(fServerArea, fArea,
fBasePointer);
if (error == B_OK)
fBasePointer += fAreaOffset;
}
if ((allocationFlags & kFramebuffer) != 0) {
// The base pointer will now point to an overlay_client_data
// structure bytes per row might be modified to match
// hardware constraints
link.Read<int32>(&bytesPerRow);
size = bytesPerRow * (bounds.IntegerHeight() + 1);
}
if (fServerArea >= B_OK) {
fSize = size;
fColorSpace = colorSpace;
fBounds = bounds;
fBytesPerRow = bytesPerRow;
fFlags = flags;
} else
error = fServerArea;
}
if (error < B_OK) {
fBasePointer = NULL;
fServerToken = -1;
fArea = -1;
fServerArea = -1;
fAreaOffset = -1;
// NOTE: why not "0" in case of error?
fFlags = flags;
} else {
BAutolock _(sBitmapListLock);
sBitmapList.AddItem(this);
}
}
fWindow = NULL;
}
fInitError = error;
if (fInitError == B_OK) {
// clear to white if the flags say so.
if (flags & (B_BITMAP_CLEAR_TO_WHITE | B_BITMAP_ACCEPTS_VIEWS)) {
if (fColorSpace == B_CMAP8) {
// "255" is the "transparent magic" index for B_CMAP8 bitmaps
// use the correct index for "white"
memset(fBasePointer, 65, fSize);
} else {
// should work for most colorspaces
memset(fBasePointer, 0xff, fSize);
}
}
// TODO: Creating an offscreen window with a non32 bit bitmap
// copies the current content of the bitmap to a back buffer.
// So at this point the bitmap has to be already cleared to white.
// Better move the above code to the server so the problem looks more
// clear.
if (flags & B_BITMAP_ACCEPTS_VIEWS) {
fWindow = new(std::nothrow) BWindow(Bounds(), fServerToken);
if (fWindow) {
// A BWindow starts life locked and is unlocked
// in Show(), but this window is never shown and
// it's message loop is never started.
fWindow->Unlock();
} else
fInitError = B_NO_MEMORY;
}
}
}