void NMGsmNetworkInterface::modemRemoved(const QString & modemUdi)
{
if (modemUdi == udi()) {
modemGsmNetworkIface = 0;
modemGsmCardIface = 0;
}
}
QString NMGsmNetworkInterface::getUdiForModemManager()
{
if (driver() != QLatin1String("bluez")) {
return udi();
}
/* BlueZ knows about the rfcommX string that we could use to find the device in ModemManager
* but does not export this info, so let's use the first bluetooth device we find in ModemManager.
* Modem will be registered in ModemManager only after someone execute its org.bluez.Serial.Connect method. */
foreach(const Solid::Control::ModemInterface *modem, Solid::Control::ModemManager::modemInterfaces()) {
if (modem->driver() == QLatin1String("bluetooth")) {
return modem->udi();
}
}
modemRemoved(udi());
return QString();
}
bool CliDevice::isMounted() const
{
if (type() != Type::Storage) {
return false;
}
QString out;
run(QString("findmnt %1").arg(udi()), &out);
return !out.isEmpty();
}
void UDisksManagerProxy::DeviceAddedCb(const DBus::SignalMessage &sig)
{
DBus::MessageIter it = sig.reader();
DBus::Path devname;
it >> devname;
DBus::Path udi(devname);
_devices[devname] = new UDisksDeviceProxy(conn(), udi);
dsyslog("[vdr-dbus] UDisksManagerProxy :: added device %s", udi.c_str());
}
bool CliDevice::mount()
{
if (type() != Type::Storage) {
return false;
}
QProcess *proc = start(QString("udisksctl mount -b %1").arg(udi()));
// QProcess *proc = start(QString("mkdir ~/`basename %1` && mount %1 ~/`basename %1`").arg(udi()));
QObject::connect(proc, (void (QProcess::*)(int))&QProcess::finished, [this, proc](int exitCode) {
if (exitCode == 0) {
emit this->mountedChanged();
}
delete proc;
});
return true;
}
/** Computes the dependencies between directories
*/
void DirDef::computeDependencies()
{
FileList *fl = m_fileList;
if (fl)
{
QListIterator<FileDef> fli(*fl);
FileDef *fd;
for (fli.toFirst();(fd=fli.current());++fli) // foreach file in dir dd
{
//printf(" File %s\n",fd->name().data());
//printf("** dir=%s file=%s\n",shortName().data(),fd->name().data());
QList<IncludeInfo> *ifl = fd->includeFileList();
if (ifl)
{
QListIterator<IncludeInfo> ifli(*ifl);
IncludeInfo *ii;
for (ifli.toFirst();(ii=ifli.current());++ifli) // foreach include file
{
//printf(" > %s\n",ii->includeName.data());
//printf(" #include %s\n",ii->includeName.data());
if (ii->fileDef && ii->fileDef->isLinkable()) // linkable file
{
DirDef *usedDir = ii->fileDef->getDirDef();
if (usedDir)
{
// add dependency: thisDir->usedDir
//static int count=0;
//printf(" %d: add dependency %s->%s\n",count++,name().data(),usedDir->name().data());
addUsesDependency(usedDir,fd,ii->fileDef,FALSE);
}
}
}
}
}
}
if (m_usedDirs)
{
QDictIterator<UsedDir> udi(*m_usedDirs);
UsedDir *udir;
for (udi.toFirst();(udir=udi.current());++udi)
{
udir->sort();
}
}
}
void computeDirDependencies()
{
DirDef *dir;
DirSDict::Iterator sdi(*Doxygen::directories);
// compute nesting level for each directory
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
dir->setLevel();
}
// compute uses dependencies between directories
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
//printf("computeDependencies for %s: #dirs=%d\n",dir->name().data(),Doxygen::directories.count());
dir->computeDependencies();
}
#if 0
printf("-------------------------------------------------------------\n");
// print dependencies (for debugging)
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
if (dir->usedDirs())
{
QDictIterator<UsedDir> udi(*dir->usedDirs());
UsedDir *usedDir;
for (udi.toFirst();(usedDir=udi.current());++udi)
{
printf("%s depends on %s due to ",
dir->shortName().data(),usedDir->dir()->shortName().data());
QDictIterator<FileDef> fdi(usedDir->files());
FileDef *fd;
for (fdi.toFirst();(fd=fdi.current());++fdi)
{
printf("%s ",fd->name().data());
}
printf("\n");
}
}
}
printf("^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^\n");
#endif
}
void FileDef::addIncludedUsingDirectives()
{
if (visited) return;
visited=TRUE;
//printf("( FileDef::addIncludedUsingDirectives for file %s\n",name().data());
NamespaceList nl;
if (includeList) // file contains #includes
{
{
QListIterator<IncludeInfo> iii(*includeList);
IncludeInfo *ii;
for (iii.toFirst();(ii=iii.current());++iii) // foreach #include...
{
if (ii->fileDef && !ii->fileDef->visited) // ...that is a known file
{
// recurse into this file
ii->fileDef->addIncludedUsingDirectives();
}
}
}
{
QListIterator<IncludeInfo> iii(*includeList);
IncludeInfo *ii;
// iterate through list from last to first
for (iii.toLast();(ii=iii.current());--iii)
{
if (ii->fileDef && ii->fileDef!=this)
{
// add using directives
NamespaceSDict *unl = ii->fileDef->usingDirList;
if (unl)
{
NamespaceSDict::Iterator nli(*unl);
NamespaceDef *nd;
for (nli.toLast();(nd=nli.current());--nli)
{
// append each using directive found in a #include file
if (usingDirList==0) usingDirList = new NamespaceSDict;
//printf("Prepending used namespace %s to the list of file %s\n",
// nd->name().data(),name().data());
if (usingDirList->find(nd->qualifiedName())==0) // not yet added
{
usingDirList->prepend(nd->qualifiedName(),nd);
}
}
}
// add using declarations
SDict<Definition> *udl = ii->fileDef->usingDeclList;
if (udl)
{
SDict<Definition>::Iterator udi(*udl);
Definition *d;
for (udi.toLast();(d=udi.current());--udi)
{
//printf("Adding using declaration %s\n",d->name().data());
if (usingDeclList==0)
{
usingDeclList = new SDict<Definition>(17);
}
if (usingDeclList->find(d->qualifiedName())==0)
{
usingDeclList->prepend(d->qualifiedName(),d);
}
}
}
}
}
}
}
//printf(") end FileDef::addIncludedUsingDirectives for file %s\n",name().data());
}
