void CUDisks2Provider::ParseInterface(const char *object, const char *iface, DBusMessageIter *propsIter)
{
if (strcmp(iface, UDISKS2_INTERFACE_DRIVE) == 0)
{
auto *drive = new Drive(object);
auto f = std::bind(&CUDisks2Provider::ParseDriveProperty, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
ParseProperties(drive, propsIter, f);
DriveAdded(drive);
}
else if (strcmp(iface, UDISKS2_INTERFACE_BLOCK) == 0)
{
auto *block = new Block(object);
auto f = std::bind(&CUDisks2Provider::ParseBlockProperty, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
ParseProperties(block, propsIter, f);
BlockAdded(block);
}
else if (strcmp(iface, UDISKS2_INTERFACE_FILESYSTEM) == 0)
{
auto *fs = new Filesystem(object);
auto f = std::bind(&CUDisks2Provider::ParseFilesystemProperty, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
ParseProperties(fs, propsIter, f);
FilesystemAdded(fs);
}
}
/*
* Start rainbow session
*/
NS_IMETHODIMP
MediaRecorder::BeginSession(
nsIPropertyBag2 *prop,
nsIDOMCanvasRenderingContext2D *ctx,
nsIMediaStateObserver *obs
)
{
canvas = ctx;
observer = obs;
ParseProperties(prop);
if (m_session) {
NS_DispatchToMainThread(new MediaCallback(
observer, "error", "session already in progress"
));
return NS_ERROR_FAILURE;
}
PR_CreateThread(
PR_SYSTEM_THREAD,
MediaRecorder::BeginSessionThread, this,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0
);
return NS_OK;
}
/*
* Start recording to file
*/
NS_IMETHODIMP
MediaRecorder::RecordToFile(
nsIPropertyBag2 *prop,
nsIDOMCanvasRenderingContext2D *ctx,
nsILocalFile *file,
nsIMediaStateObserver *obs
)
{
nsresult rv;
ParseProperties(prop);
canvas = ctx;
observer = obs;
/* Get a file stream from the local file */
nsCOMPtr<nsIFileOutputStream> stream(
do_CreateInstance("@mozilla.org/network/file-output-stream;1")
);
pipeStream = do_QueryInterface(stream, &rv);
if (NS_FAILED(rv)) return rv;
rv = stream->Init(file, -1, -1, 0);
if (NS_FAILED(rv)) return rv;
thread = PR_CreateThread(
PR_SYSTEM_THREAD,
MediaRecorder::Record, this,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0
);
return NS_OK;
}
bool CUDisks2Provider::FilesystemPropertiesChanged(const char *object, DBusMessageIter *propsIter, IStorageEventsCallback *callback)
{
if (m_filesystems.count(object) > 0)
{
auto fs = m_filesystems[object];
CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Before update: %s", fs->toString());
bool wasMounted = fs->m_isMounted;
auto ParseFilesystemProperty = std::bind(&CUDisks2Provider::ParseFilesystemProperty, this,
std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
ParseProperties(fs, propsIter, ParseFilesystemProperty);
CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: After update: %s", fs->toString());
if (!wasMounted && fs->m_isMounted && fs->IsApproved())
{
CLog::Log(LOGINFO, "UDisks2: Added %s", fs->m_mountPoint);
if (callback)
callback->OnStorageAdded(fs->GetDisplayName(), fs->m_mountPoint);
return true;
}
else if (wasMounted && !fs->m_isMounted)
{
CLog::Log(LOGINFO, "UDisks2: Removed %s", fs->m_block->m_device);
if (callback)
callback->OnStorageSafelyRemoved(fs->GetDisplayName());
return true;
}
}
return false;
}
bool BodyMeshLoader::ParseBone (iDocumentNode* node, iLoaderContext* ldr_context,
CS::Animation::iBodySkeleton* skeleton)
{
// parse bone name
const char* name = node->GetAttributeValue ("name");
if (!name)
{
synldr->ReportError (msgid, node, "No name set for bone");
return false;
}
CS::Animation::BoneID id = skeleton->GetSkeletonFactory ()->FindBone (name);
if (id == CS::Animation::InvalidBoneID)
{
synldr->ReportError (msgid, node, "No bone with name %s in skeleton factory",
name);
return false;
}
// create body bone
CS::Animation::iBodyBone* bone = skeleton->CreateBodyBone (id);
// parse child nodes
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
const char* value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch (id)
{
case XMLTOKEN_PROPERTIES:
if (!ParseProperties (child, bone))
return false;
break;
case XMLTOKEN_COLLIDERS:
if (!ParseColliders (child, ldr_context, bone))
return false;
break;
case XMLTOKEN_JOINT:
if (!ParseJoint (child, bone))
return false;
break;
default:
synldr->ReportBadToken (child);
return false;
}
}
return true;
}
bool CUDisks2Provider::BlockPropertiesChanged(const char *object, DBusMessageIter *propsIter)
{
if (m_blocks.count(object) > 0)
{
auto block = m_blocks[object];
CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Before update: %s", block->toString());
auto ParseBlockProperty = std::bind(&CUDisks2Provider::ParseBlockProperty, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
ParseProperties(block, propsIter, ParseBlockProperty);
CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: After update: %s", block->toString());
}
return false;
}
internal bool
KwmParseRule(std::string RuleSym, window_rule *Rule)
{
tokenizer Tokenizer = {};
Tokenizer.At = const_cast<char*>(RuleSym.c_str());
bool Result = true;
bool Parsing = true;
while(Parsing)
{
token Token = GetToken(&Tokenizer);
switch(Token.Type)
{
case Token_EndOfStream:
{
Parsing = false;
} break;
case Token_Unknown:
{
} break;
case Token_Identifier:
{
if(TokenEquals(Token, "owner"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Owner);
else if(TokenEquals(Token, "name"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Name);
else if(TokenEquals(Token, "role"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Role);
else if(TokenEquals(Token, "crole"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->CustomRole);
else if(TokenEquals(Token, "properties"))
Result = Result && ParseProperties(&Tokenizer, &Rule->Properties);
else if(TokenEquals(Token, "except"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Except);
} break;
default: { } break;
}
}
return Result;
}
