// =
BCurrency &
BCurrency::operator=(const BCurrency &other)
{
if (other.InitCheck() == B_OK) {
fCurrencyCode = other.fCurrencyCode;
fDefaultSymbol = other.fDefaultSymbol;
fDefaultFractionDigits = other.fDefaultFractionDigits;
if (!_CheckData())
_Unset(B_NO_MEMORY);
} else
_Unset(B_NO_MEMORY);
return *this;
}
status_t
TeamSettings::SetTo(Team* team)
{
_Unset();
AutoLocker<Team> locker(team);
fTeamName = team->Name();
// add breakpoints
for (UserBreakpointList::ConstIterator it
= team->UserBreakpoints().GetIterator();
UserBreakpoint* breakpoint = it.Next();) {
BreakpointSetting* breakpointSetting
= new(std::nothrow) BreakpointSetting;
if (breakpointSetting == NULL)
return B_NO_MEMORY;
status_t error = breakpointSetting->SetTo(breakpoint->Location(),
breakpoint->IsEnabled(), breakpoint->IsHidden());
if (error == B_OK && !fBreakpoints.AddItem(breakpointSetting))
error = B_NO_MEMORY;
if (error != B_OK) {
delete breakpointSetting;
return error;
}
}
return B_OK;
}
status_t
BreakpointSetting::SetTo(const BMessage& archive)
{
_Unset();
fFunctionID = ArchivingUtils::UnarchiveChild<FunctionID>(archive,
"function");
if (fFunctionID == NULL)
return B_BAD_VALUE;
archive.FindString("sourceFile", &fSourceFile);
int32 line;
if (archive.FindInt32("line", &line) != B_OK)
line = -1;
int32 column;
if (archive.FindInt32("column", &column) != B_OK)
column = -1;
fSourceLocation = SourceLocation(line, column);
if (archive.FindUInt64("relativeAddress", &fRelativeAddress) != B_OK)
fRelativeAddress = 0;
if (archive.FindBool("enabled", &fEnabled) != B_OK)
fEnabled = false;
return B_OK;
}
TeamSettings&
TeamSettings::operator=(const TeamSettings& other)
{
if (this == &other)
return *this;
_Unset();
fTeamName = other.fTeamName;
for (int32 i = 0; BreakpointSetting* breakpoint
= other.fBreakpoints.ItemAt(i); i++) {
BreakpointSetting* clonedBreakpoint
= new BreakpointSetting(*breakpoint);
if (!fBreakpoints.AddItem(clonedBreakpoint)) {
delete clonedBreakpoint;
throw std::bad_alloc();
}
}
for (int32 i = 0; TeamUiSettings* uiSetting
= other.fUiSettings.ItemAt(i); i++) {
TeamUiSettings* clonedSetting
= uiSetting->Clone();
if (!fUiSettings.AddItem(clonedSetting)) {
delete clonedSetting;
throw std::bad_alloc();
}
}
*fFileManagerSettings = *other.fFileManagerSettings;
return *this;
}
// _Init
status_t
BlockerPool::_Init(int32 count)
{
_Unset();
AutoLocker<BlockerPool> locker(this);
if (!locker.IsLocked())
return B_ERROR;
// create semaphore
fFreeBlockersSemaphore = create_sem(0, "blocker pool free blockers");
if (fFreeBlockersSemaphore < 0)
return fFreeBlockersSemaphore;
// allocate blocker vector
fBlockers = new(nothrow) BlockerVector;
if (!fBlockers)
return B_NO_MEMORY;
fInitStatus = B_OK;
// create and add blockers
for (int32 i = 0; i < count; i++) {
Blocker blocker;
status_t error = blocker.InitCheck();
if (error != B_OK)
return error;
error = PutBlocker(blocker);
if (error != B_OK)
return error;
}
return B_OK;
}
status_t
device_attr_private::CopyFrom(const device_attr& attr)
{
name = strdup(attr.name);
if (name == NULL)
return B_NO_MEMORY;
type = attr.type;
switch (type) {
case B_UINT8_TYPE:
case B_UINT16_TYPE:
case B_UINT32_TYPE:
case B_UINT64_TYPE:
value.ui64 = attr.value.ui64;
break;
case B_STRING_TYPE:
if (attr.value.string != NULL) {
value.string = strdup(attr.value.string);
if (value.string == NULL) {
_Unset();
return B_NO_MEMORY;
}
} else
value.string = NULL;
break;
case B_RAW_TYPE:
value.raw.data = malloc(attr.value.raw.length);
if (value.raw.data == NULL) {
_Unset();
return B_NO_MEMORY;
}
value.raw.length = attr.value.raw.length;
memcpy((void*)value.raw.data, attr.value.raw.data,
attr.value.raw.length);
break;
default:
return B_BAD_VALUE;
}
return B_OK;
}
TeamSettings::TeamSettings(const TeamSettings& other)
{
try {
*this = other;
} catch (...) {
_Unset();
throw;
}
}
// constructor
BlockerPool::BlockerPool(int32 count)
: Locker("blocker pool"),
fFreeBlockersSemaphore(-1),
fBlockers(NULL),
fInitStatus(B_NO_INIT)
{
fInitStatus = _Init(count);
if (fInitStatus != B_OK)
_Unset();
}
status_t
TeamSettings::SetTo(const BMessage& archive,
const TeamUiSettingsFactory& factory)
{
_Unset();
status_t error = archive.FindString("teamName", &fTeamName);
if (error != B_OK)
return error;
// add breakpoints
BMessage childArchive;
for (int32 i = 0; archive.FindMessage("breakpoints", i, &childArchive)
== B_OK; i++) {
BreakpointSetting* breakpointSetting
= new(std::nothrow) BreakpointSetting;
if (breakpointSetting == NULL)
return B_NO_MEMORY;
error = breakpointSetting->SetTo(childArchive);
if (error == B_OK && !fBreakpoints.AddItem(breakpointSetting))
error = B_NO_MEMORY;
if (error != B_OK) {
delete breakpointSetting;
return error;
}
}
// add UI settings
for (int32 i = 0; archive.FindMessage("uisettings", i, &childArchive)
== B_OK; i++) {
TeamUiSettings* setting = NULL;
error = factory.Create(childArchive, setting);
if (error == B_OK && !fUiSettings.AddItem(setting))
error = B_NO_MEMORY;
if (error != B_OK) {
delete setting;
return error;
}
}
if (archive.FindMessage("filemanagersettings", &childArchive) == B_OK) {
error = fFileManagerSettings->SetTo(childArchive);
if (error != B_OK)
return error;
}
if (archive.FindMessage("signalsettings", &childArchive) == B_OK) {
error = fSignalSettings->SetTo(childArchive);
if (error != B_OK)
return error;
}
return B_OK;
}
status_t
GUITeamUISettings::_SetTo(const GUITeamUISettings& other)
{
_Unset();
fID = other.fID;
fValues = other.fValues;
return B_OK;
}
status_t
EventDispatcher::SetTo(EventStream* stream)
{
ETRACE(("event dispatcher: stream = %p\n", stream));
_Unset();
if (stream == NULL)
return B_OK;
fStream = stream;
return _Run();
}
// constructor
BCurrency::BCurrency(BMessage *archive)
: fCurrencyCode(),
fDefaultSymbol(),
fDefaultFractionDigits(B_NO_INIT)
{
if (archive->FindString(kArchivedCurrencyCodeName, &fCurrencyCode)
== B_OK
&& archive->FindString(kArchivedDefaultSymbol, &fDefaultSymbol)
== B_OK
&& archive->FindInt32(kArchivedDefaultFractionDigits,
&fDefaultFractionDigits) == B_OK
&& _CheckData()) {
// everything went fine
} else
_Unset(B_NO_INIT);
}
status_t
TeamSettings::SetTo(Team* team)
{
_Unset();
AutoLocker<Team> locker(team);
fTeamName = team->Name();
// add breakpoints
for (UserBreakpointList::ConstIterator it
= team->UserBreakpoints().GetIterator();
UserBreakpoint* breakpoint = it.Next();) {
BreakpointSetting* breakpointSetting
= new(std::nothrow) BreakpointSetting;
if (breakpointSetting == NULL)
return B_NO_MEMORY;
status_t error = breakpointSetting->SetTo(breakpoint->Location(),
breakpoint->IsEnabled(), breakpoint->IsHidden(),
breakpoint->Condition());
if (error == B_OK && !fBreakpoints.AddItem(breakpointSetting))
error = B_NO_MEMORY;
if (error != B_OK) {
delete breakpointSetting;
return error;
}
}
// add signal configuration
fSignalSettings->SetDefaultSignalDisposition(
team->DefaultSignalDisposition());
const SignalDispositionMappings& mappings
= team->GetSignalDispositionMappings();
for (SignalDispositionMappings::const_iterator it = mappings.begin();
it != mappings.end(); ++it) {
status_t error = fSignalSettings->AddCustomSignalDisposition(
it->first, it->second);
if (error != B_OK)
return error;
}
return B_OK;
}
status_t
BreakpointSetting::SetTo(const UserBreakpointLocation& location, bool enabled)
{
_Unset();
fFunctionID = location.GetFunctionID();
if (fFunctionID != NULL)
fFunctionID->AcquireReference();
if (LocatableFile* file = location.SourceFile())
file->GetPath(fSourceFile);
fSourceLocation = location.GetSourceLocation();
fRelativeAddress = location.RelativeAddress();
fEnabled = enabled;
return B_OK;
}
BreakpointSetting&
BreakpointSetting::operator=(const BreakpointSetting& other)
{
if (this == &other)
return *this;
_Unset();
fFunctionID = other.fFunctionID;
if (fFunctionID != NULL)
fFunctionID->AcquireReference();
fSourceFile = other.fSourceFile;
fSourceLocation = other.fSourceLocation;
fRelativeAddress = other.fRelativeAddress;
fEnabled = other.fEnabled;
return *this;
}
TeamSettings::~TeamSettings()
{
_Unset();
}
GUITeamUISettings::~GUITeamUISettings()
{
_Unset();
}
BreakpointSetting::~BreakpointSetting()
{
_Unset();
}
void
EventDispatcher::_EventLoop()
{
BMessage* event;
while (fStream->GetNextEvent(&event)) {
BAutolock _(this);
fLastUpdate = system_time();
EventTarget* current = NULL;
EventTarget* previous = NULL;
bool pointerEvent = false;
bool keyboardEvent = false;
bool addedTokens = false;
switch (event->what) {
case kFakeMouseMoved:
_SendFakeMouseMoved(event);
break;
case B_MOUSE_MOVED:
{
BPoint where;
if (event->FindPoint("where", &where) == B_OK)
fLastCursorPosition = where;
if (fDraggingMessage)
event->AddMessage("be:drag_message", &fDragMessage);
if (!HasCursorThread()) {
// There is no cursor thread, we need to move the cursor
// ourselves
BAutolock _(fCursorLock);
if (fHWInterface != NULL) {
fHWInterface->MoveCursorTo(fLastCursorPosition.x,
fLastCursorPosition.y);
}
}
// This is for B_NO_POINTER_HISTORY - we always want the
// latest mouse moved event in the queue only
if (fNextLatestMouseMoved == NULL)
fNextLatestMouseMoved = fStream->PeekLatestMouseMoved();
else if (fNextLatestMouseMoved != event) {
// Drop older mouse moved messages if the server is lagging
// too much (if the message is older than 100 msecs)
bigtime_t eventTime;
if (event->FindInt64("when", &eventTime) == B_OK) {
if (system_time() - eventTime > 100000)
break;
}
}
// supposed to fall through
}
case B_MOUSE_DOWN:
case B_MOUSE_UP:
{
#ifdef TRACE_EVENTS
if (event->what != B_MOUSE_MOVED)
printf("mouse up/down event, previous target = %p\n", fPreviousMouseTarget);
#endif
pointerEvent = true;
if (fMouseFilter == NULL)
break;
EventTarget* mouseTarget = fPreviousMouseTarget;
int32 viewToken = B_NULL_TOKEN;
if (fMouseFilter->Filter(event, &mouseTarget, &viewToken,
fNextLatestMouseMoved) == B_SKIP_MESSAGE) {
// this is a work-around if the wrong B_MOUSE_UP
// event is filtered out
if (event->what == B_MOUSE_UP
&& event->FindInt32("buttons") == 0) {
fSuspendFocus = false;
_RemoveTemporaryListeners();
}
break;
}
int32 buttons;
if (event->FindInt32("buttons", &buttons) == B_OK)
fLastButtons = buttons;
else
fLastButtons = 0;
// The "where" field will be filled in by the receiver
// (it's supposed to be expressed in local window coordinates)
event->RemoveName("where");
event->AddPoint("screen_where", fLastCursorPosition);
if (event->what == B_MOUSE_MOVED
&& fPreviousMouseTarget != NULL
&& mouseTarget != fPreviousMouseTarget) {
// Target has changed, we need to notify the previous target
// that the mouse has exited its views
addedTokens = _AddTokens(event, fPreviousMouseTarget,
B_POINTER_EVENTS);
if (addedTokens)
_SetFeedFocus(event);
_SendMessage(fPreviousMouseTarget->Messenger(), event,
kMouseTransitImportance);
previous = fPreviousMouseTarget;
}
current = fPreviousMouseTarget = mouseTarget;
if (current != NULL) {
int32 focusView = viewToken;
addedTokens |= _AddTokens(event, current, B_POINTER_EVENTS,
fNextLatestMouseMoved, &focusView);
bool noPointerHistoryFocus = focusView != viewToken;
if (viewToken != B_NULL_TOKEN)
event->AddInt32("_view_token", viewToken);
if (addedTokens && !noPointerHistoryFocus)
_SetFeedFocus(event);
else if (noPointerHistoryFocus) {
// No tokens were added or the focus shouldn't get a
// mouse moved
break;
}
_SendMessage(current->Messenger(), event,
event->what == B_MOUSE_MOVED
? kMouseMovedImportance : kStandardImportance);
}
break;
}
case B_KEY_DOWN:
case B_KEY_UP:
case B_UNMAPPED_KEY_DOWN:
case B_UNMAPPED_KEY_UP:
case B_MODIFIERS_CHANGED:
case B_INPUT_METHOD_EVENT:
ETRACE(("key event, focus = %p\n", fFocus));
if (fKeyboardFilter != NULL
&& fKeyboardFilter->Filter(event, &fFocus) == B_SKIP_MESSAGE)
break;
keyboardEvent = true;
if (fFocus != NULL && _AddTokens(event, fFocus,
B_KEYBOARD_EVENTS)) {
// if tokens were added, we need to explicetly suspend
// focus in the event - if not, the event is simply not
// forwarded to the target
addedTokens = true;
if (!fSuspendFocus)
_SetFeedFocus(event);
}
// supposed to fall through
default:
// TODO: the keyboard filter sets the focus - ie. no other
// focus messages that go through the event dispatcher can
// go through.
if (event->what == B_MOUSE_WHEEL_CHANGED)
current = fPreviousMouseTarget;
else
current = fFocus;
if (current != NULL && (!fSuspendFocus || addedTokens)) {
_SendMessage(current->Messenger(), event,
kStandardImportance);
}
break;
}
if (keyboardEvent || pointerEvent) {
// send the event to the additional listeners
if (addedTokens) {
_RemoveTokens(event);
_UnsetFeedFocus(event);
}
if (pointerEvent) {
// this is added in the Desktop mouse processing
// but it's only intended for the focus view
event->RemoveName("_view_token");
}
for (int32 i = fTargets.CountItems(); i-- > 0;) {
EventTarget* target = fTargets.ItemAt(i);
// We already sent the event to the all focus and last focus
// tokens
if (current == target || previous == target)
continue;
// Don't send the message if there are no tokens for this event
if (!_AddTokens(event, target,
keyboardEvent ? B_KEYBOARD_EVENTS : B_POINTER_EVENTS,
event->what == B_MOUSE_MOVED
? fNextLatestMouseMoved : NULL))
continue;
if (!_SendMessage(target->Messenger(), event,
event->what == B_MOUSE_MOVED
? kMouseMovedImportance : kListenerImportance)) {
// the target doesn't seem to exist anymore, let's remove it
fTargets.RemoveItemAt(i);
}
}
if (event->what == B_MOUSE_UP && fLastButtons == 0) {
// no buttons are pressed anymore
fSuspendFocus = false;
_RemoveTemporaryListeners();
if (fDraggingMessage)
_DeliverDragMessage();
}
}
if (fNextLatestMouseMoved == event)
fNextLatestMouseMoved = NULL;
delete event;
}
// The loop quit, therefore no more events are coming from the input
// server, it must have died. Unset ourselves and notify the desktop.
fThread = -1;
// Needed to avoid problems with wait_for_thread in _Unset()
_Unset();
if (fDesktop)
fDesktop->PostMessage(AS_EVENT_STREAM_CLOSED);
}
EventDispatcher::~EventDispatcher()
{
_Unset();
}
// destructor
BlockerPool::~BlockerPool()
{
_Unset();
}
/*! \brief Reads through the database and builds a complete set of installed types lists.
An initial set of cached messages are also created.
*/
status_t
InstalledTypes::_BuildInstalledTypesList()
{
status_t err = B_OK;
_Unset();
// Create empty "cached messages" so proper messages
// will be built up as we add new types
try {
fCachedMessage = new BMessage();
fCachedSupertypesMessage = new BMessage();
} catch (std::bad_alloc) {
err = B_NO_MEMORY;
}
BDirectory root;
if (!err)
err = root.SetTo(get_database_directory().c_str());
if (!err) {
root.Rewind();
while (true) {
BEntry entry;
err = root.GetNextEntry(&entry);
if (err) {
// If we've come to the end of list, it's not an error
if (err == B_ENTRY_NOT_FOUND)
err = B_OK;
break;
} else {
// Check that this entry is both a directory and a valid MIME string
char supertype[B_PATH_NAME_LENGTH];
if (entry.IsDirectory()
&& entry.GetName(supertype) == B_OK
&& BMimeType::IsValid(supertype))
{
// Make sure our string is all lowercase
BPrivate::Storage::to_lower(supertype);
// Add this supertype
std::map<std::string, Supertype>::iterator i;
if (_AddSupertype(supertype, i) != B_OK)
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList() -- Error adding supertype '%s': 0x%lx\n",
supertype, err));
Supertype &supertypeRef = fSupertypes[supertype];
// Now iterate through this supertype directory and add
// all of its subtypes
BDirectory dir;
if (dir.SetTo(&entry) == B_OK) {
dir.Rewind();
while (true) {
BEntry subEntry;
err = dir.GetNextEntry(&subEntry);
if (err) {
// If we've come to the end of list, it's not an error
if (err == B_ENTRY_NOT_FOUND)
err = B_OK;
break;
} else {
// We need to preserve the case of the type name for
// queries, so we can't use the file name directly
BString type;
int32 subStart;
BNode node(&subEntry);
if (node.InitCheck() == B_OK
&& node.ReadAttrString(kTypeAttr, &type) >= B_OK
&& (subStart = type.FindFirst('/')) > 0) {
// Add the subtype
if (_AddSubtype(supertypeRef, type.String()
+ subStart + 1) != B_OK) {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList() -- Error adding subtype '%s/%s': 0x%lx\n",
supertype, type.String() + subStart + 1, err));
}
}
}
}
} else {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList(): "
"Failed opening supertype directory '%s'\n",
supertype));
}
}
}
}
} else {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList(): "
"Failed opening mime database directory '%s'\n",
get_database_directory().c_str()));
}
fHaveDoneFullBuild = true;
return err;
}
device_attr_private::~device_attr_private()
{
_Unset();
}
