static status_t
packagefs_get_vnode(fs_volume* fsVolume, ino_t vnid, fs_vnode* fsNode,
int* _type, uint32* _flags, bool reenter)
{
Volume* volume = (Volume*)fsVolume->private_volume;
FUNCTION("volume: %p, vnid: %" B_PRId64 "\n", volume, vnid);
VolumeReadLocker volumeLocker(volume);
Node* node = volume->FindNode(vnid);
if (node == NULL)
return B_ENTRY_NOT_FOUND;
BReference<Node> nodeReference(node);
volumeLocker.Unlock();
NodeWriteLocker nodeLocker(node);
status_t error = node->VFSInit(volume->ID());
if (error != B_OK)
RETURN_ERROR(error);
nodeLocker.Unlock();
fsNode->private_node = nodeReference.Detach();
fsNode->ops = &gPackageFSVnodeOps;
*_type = node->Mode() & S_IFMT;
*_flags = 0;
return B_OK;
}
status_t
VariablesView::VariableTableModel::_AddNode(Variable* variable,
ModelNode* parent, ValueNodeChild* nodeChild, bool isPresentationNode)
{
// Don't create nodes for unspecified types -- we can't get/show their
// value anyway.
Type* nodeChildRawType = nodeChild->GetType()->ResolveRawType(false);
if (nodeChildRawType->Kind() == TYPE_UNSPECIFIED)
return B_OK;
ModelNode* node = new(std::nothrow) ModelNode(parent, variable, nodeChild,
isPresentationNode);
BReference<ModelNode> nodeReference(node, true);
if (node == NULL || node->Init() != B_OK)
return B_NO_MEMORY;
int32 childIndex;
if (parent != NULL) {
childIndex = parent->CountChildren();
if (!parent->AddChild(node))
return B_NO_MEMORY;
// the parent has a reference, now
} else {
childIndex = fNodes.CountItems();
if (!fNodes.AddItem(node))
return B_NO_MEMORY;
nodeReference.Detach();
// the fNodes list has a reference, now
}
fNodeTable.Insert(node);
// mark a compound type child of a address type parent hidden
if (parent != NULL) {
ValueNode* parentValueNode = parent->NodeChild()->Node();
if (parentValueNode != NULL
&& parentValueNode->GetType()->ResolveRawType(false)->Kind()
== TYPE_ADDRESS
&& nodeChildRawType->Kind() == TYPE_COMPOUND) {
node->SetHidden(true);
}
}
// notify table model listeners
if (!node->IsHidden()) {
TreeTablePath path;
if (parent == NULL || _GetTreePath(parent, path))
NotifyNodesAdded(path, childIndex, 1);
}
// if the node is hidden, add its children
if (node->IsHidden())
_AddChildNodes(nodeChild);
return B_OK;
}
void
VariablesView::ContainerListener::ValueNodeValueChanged(ValueNode* node)
{
// If the looper is already locked, invoke the model's hook synchronously.
if (fIndirectTarget->Looper()->IsLocked()) {
fModel->ValueNodeValueChanged(node);
return;
}
// looper not locked yet -- call asynchronously to avoid reverse locking
// order
BReference<ValueNode> nodeReference(node);
BMessage message(MSG_VALUE_NODE_VALUE_CHANGED);
if (message.AddPointer("node", node) == B_OK
&& fIndirectTarget->Looper()->PostMessage(&message, fIndirectTarget)
== B_OK) {
nodeReference.Detach();
}
}
static status_t
packagefs_lookup(fs_volume* fsVolume, fs_vnode* fsDir, const char* entryName,
ino_t* _vnid)
{
Volume* volume = (Volume*)fsVolume->private_volume;
Node* dir = (Node*)fsDir->private_node;
FUNCTION("volume: %p, dir: %p (%" B_PRId64 "), entry: \"%s\"\n", volume,
dir, dir->ID(), entryName);
if (!S_ISDIR(dir->Mode()))
return B_NOT_A_DIRECTORY;
// resolve "."
if (strcmp(entryName, ".") == 0) {
Node* node;
*_vnid = dir->ID();
return volume->GetVNode(*_vnid, node);
}
// resolve ".."
if (strcmp(entryName, "..") == 0) {
Node* node;
*_vnid = dir->Parent()->ID();
return volume->GetVNode(*_vnid, node);
}
// resolve normal entries -- look up the node
NodeReadLocker dirLocker(dir);
String entryNameString;
Node* node = dynamic_cast<Directory*>(dir)->FindChild(StringKey(entryName));
if (node == NULL)
return B_ENTRY_NOT_FOUND;
BReference<Node> nodeReference(node);
dirLocker.Unlock();
// get the vnode reference
*_vnid = node->ID();
RETURN_ERROR(volume->GetVNode(*_vnid, node));
}
void
VariablesView::MessageReceived(BMessage* message)
{
switch (message->what) {
case MSG_VALUE_NODE_CHANGED:
{
ValueNodeChild* nodeChild;
ValueNode* oldNode;
ValueNode* newNode;
if (message->FindPointer("nodeChild", (void**)&nodeChild) == B_OK
&& message->FindPointer("oldNode", (void**)&oldNode) == B_OK
&& message->FindPointer("newNode", (void**)&newNode) == B_OK) {
BReference<ValueNodeChild> nodeChildReference(nodeChild, true);
BReference<ValueNode> oldNodeReference(oldNode, true);
BReference<ValueNode> newNodeReference(newNode, true);
fVariableTableModel->ValueNodeChanged(nodeChild, oldNode,
newNode);
}
break;
}
case MSG_VALUE_NODE_CHILDREN_CREATED:
{
ValueNode* node;
if (message->FindPointer("node", (void**)&node) == B_OK) {
BReference<ValueNode> newNodeReference(node, true);
fVariableTableModel->ValueNodeChildrenCreated(node);
}
break;
}
case MSG_VALUE_NODE_CHILDREN_DELETED:
{
ValueNode* node;
if (message->FindPointer("node", (void**)&node) == B_OK) {
BReference<ValueNode> newNodeReference(node, true);
fVariableTableModel->ValueNodeChildrenDeleted(node);
}
break;
}
case MSG_VALUE_NODE_VALUE_CHANGED:
{
ValueNode* node;
if (message->FindPointer("node", (void**)&node) == B_OK) {
BReference<ValueNode> newNodeReference(node, true);
fVariableTableModel->ValueNodeValueChanged(node);
}
break;
}
case MSG_VARIABLES_VIEW_CONTEXT_MENU_DONE:
{
_FinishContextMenu(false);
break;
}
case MSG_VARIABLES_VIEW_NODE_SETTINGS_CHANGED:
{
ModelNode* node;
if (message->FindPointer("node", (void**)&node) != B_OK)
break;
BReference<ModelNode> nodeReference(node, true);
fVariableTableModel->NotifyNodeChanged(node);
break;
}
default:
BGroupView::MessageReceived(message);
break;
}
}
