Source Code (Use browser search to find items of interest.)
Class Index
kdf'DiskEntry (./kdeutils/kdf/disks.h:39)
class DiskEntry : public QObject
{
Q_OBJECT
public:
DiskEntry(QObject *parent=0, const char *name=0);
DiskEntry(QString deviceName, QObject *parent=0, const char *name=0);
~DiskEntry();
QString lastSysError() {return sysStringErrOut; };
QString deviceName() const { return device; };
QString mountPoint() const { return mountedOn; };
QString mountOptions() const { return options; };
/**
* sets the used mountCommand for the actual DiskEntry.
* @param mntcmd is a string containing the executable file and
* special codes which will be filled in when used: <BR>
* %m : mountpoint <BR>
* %d : deviceName <BR>
* %t : filesystem type <BR>
* %o : mount options <BR>
* all this information is gained from the objects' data
* if no mountCommand is set it defaults to "mount %d"
**/
QString mountCommand() const { return mntcmd; };
/**
* sets the used umountCommand for the actual DiskEntry.
* @param mntcmd is a string containing the executable file and
* special codes which will be filled in when used: <BR>
* %m : mountpoint <BR>
* %d : deviceName <BR>
* all this information is gained from the objects' data
* if no umountCommand is set it defaults to "umount %d"
**/
QString umountCommand() const { return umntcmd; };
QString fsType() const { return type; };
bool mounted() const { return isMounted; };
int kBSize() const { return size; };
QString iconName();
QString realIconName() { return icoName; };
QString prettyKBSize() const { return prettyPrint(size); };
int kBUsed() const { return used; };
QString prettyKBUsed() const { return prettyPrint(used); };
int kBAvail() const { return avail; };
QString prettyKBAvail() const { return prettyPrint(avail); };
float percentFull() const;
signals:
void sysCallError(DiskEntry *disk, int errno);
void deviceNameChanged();
void mountPointChanged();
void mountOptionsChanged();
void fsTypeChanged();
void mountedChanged();
void kBSizeChanged();
void kBUsedChanged();
void kBAvailChanged();
void iconNameChanged();
public slots:
int toggleMount();
int mount();
int umount();
int remount();
void setMountCommand(QString mnt);
void setUmountCommand(QString umnt);
void setDeviceName(QString deviceName);
void setMountPoint(QString mountPoint);
void setIconName(QString iconName);
void setMountOptions(QString mountOptions);
void setFsType(QString fsType);
void setMounted(bool nowMounted);
void setKBSize(int kb_size);
void setKBUsed(int kb_used);
void setKBAvail(int kb_avail);
QString guessIconName();
private slots:
void receivedSysStdErrOut(KProcess *, char *data, int len);
private:
void init();
int sysCall(QString command);
QString prettyPrint(int kBValue) const;
KShellProcess *sysProc;
QString sysStringErrOut;
bool readingSysStdErrOut;
QString device,
type,
mountedOn,
options,
icoName,
mntcmd,
umntcmd;
int size,
used,
avail; // ATTENTION: used+avail != size (clustersize!)
bool isMounted,
iconSetByUser;
};
kdf'DiskEntry::init() (./kdeutils/kdf/disks.cpp:39)
void DiskEntry::init()
{
device="";
type="";
mountedOn="";
options="";
size=0;
used=0;
avail=0;
isMounted=FALSE;
mntcmd="";
umntcmd="";
iconSetByUser=FALSE;
icoName="";
// BackgroundProcesses ****************************************
sysProc = new KShellProcess(); CHECK_PTR(sysProc);
connect( sysProc, SIGNAL(receivedStdout(KProcess *, char *, int) ),
this, SLOT (receivedSysStdErrOut(KProcess *, char *, int)) );
connect( sysProc, SIGNAL(receivedStderr(KProcess *, char *, int) ),
this, SLOT (receivedSysStdErrOut(KProcess *, char *, int)) );
readingSysStdErrOut=FALSE;
}
kdf'DiskEntry::DiskEntry() (./kdeutils/kdf/disks.cpp:67)
DiskEntry::DiskEntry(QObject *parent, const char *name)
: QObject (parent, name)
{
init();
}
kdf'DiskEntry::DiskEntry() (./kdeutils/kdf/disks.cpp:73)
DiskEntry::DiskEntry(QString deviceName, QObject *parent, const char *name)
: QObject (parent, name)
{
init();
debug("devname: %s", deviceName.latin1());
setDeviceName(deviceName);
}
kdf'DiskEntry::~DiskEntry() (./kdeutils/kdf/disks.cpp:81)
DiskEntry::~DiskEntry()
{
debug("DESTRUCT: DiskList");
disconnect(this);
delete sysProc;
};
kdf'DiskEntry::toggleMount() (./kdeutils/kdf/disks.cpp:88)
int DiskEntry::toggleMount()
{
if (!mounted())
return mount();
else
return umount();
};
kdf'DiskEntry::mount() (./kdeutils/kdf/disks.cpp:96)
int DiskEntry::mount()
{
debug("mounting");
QString cmdS=mntcmd;
if (cmdS.isEmpty()) // generate default mount cmd
if (getuid()!=0 ) // user mountable
cmdS="mount %d";
else // root mounts with all params/options
cmdS="mount -t%t %d %m -o %o";
cmdS.replace(QRegExp("%d"),this->deviceName());
cmdS.replace(QRegExp("%m"),this->mountPoint());
cmdS.replace(QRegExp("%t"),this->fsType());
cmdS.replace(QRegExp("%o"),this->mountOptions());
debug("mount-cmd: [%s]",(const char *)cmdS);
int e=sysCall(cmdS);
if (!e) setMounted(TRUE);
debug("mount-cmd: e=%d", e);
return e;
};
kdf'DiskEntry::umount() (./kdeutils/kdf/disks.cpp:118)
int DiskEntry::umount()
{
debug("umounting");
QString cmdS=umntcmd;
if (cmdS.isEmpty()) // generate default umount cmd
cmdS="umount %d";
cmdS.replace(QRegExp("%d"),this->deviceName());
cmdS.replace(QRegExp("%m"),this->mountPoint());
debug("umount-cmd: [%s]",(const char *)cmdS);
int e=sysCall(cmdS);
if (!e) setMounted(FALSE);
debug("umount-cmd: e=%d", e);
return e;
};
kdf'DiskEntry::remount() (./kdeutils/kdf/disks.cpp:135)
int DiskEntry::remount()
{
QString cmdS;
if (mntcmd.isEmpty() && umntcmd.isEmpty() // default mount/umount commands
&& (getuid()==0)) // you are root
{
QString oldOpt=options;
if (options.isEmpty())
options="remount";
else
options+=",remount";
int e=this->mount();
options=oldOpt;
return e;
} else {
if (int e=this->umount())
return this->mount();
else return e;
}
};
kdf'DiskEntry::setMountCommand() (./kdeutils/kdf/disks.cpp:156)
void DiskEntry::setMountCommand(QString mnt)
{
mntcmd=mnt;
};
kdf'DiskEntry::setUmountCommand() (./kdeutils/kdf/disks.cpp:161)
void DiskEntry::setUmountCommand(QString umnt)
{
umntcmd=umnt;
};
kdf'DiskEntry::setIconName() (./kdeutils/kdf/disks.cpp:166)
void DiskEntry::setIconName(QString iconName)
{
iconSetByUser=TRUE;
icoName=iconName;
emit iconNameChanged();
};
kdf'DiskEntry::iconName() (./kdeutils/kdf/disks.cpp:173)
QString DiskEntry::iconName()
{
QString iconName=icoName;
if (iconSetByUser) {
mounted() ? iconName+="_mount.png" : iconName+="_unmount.png";
return iconName;
} else
return guessIconName();
};
kdf'DiskEntry::guessIconName() (./kdeutils/kdf/disks.cpp:183)
QString DiskEntry::guessIconName()
{
QString iconName;
iconName="devices/";
// try to be intelligent
if (-1!=mountPoint().find("cdrom",0,FALSE)) iconName+="cdrom";
else if (-1!=deviceName().find("cdrom",0,FALSE)) iconName+="cdrom";
else if (-1!=mountPoint().find("writer",0,FALSE)) iconName+="cdwriter";
else if (-1!=deviceName().find("writer",0,FALSE)) iconName+="cdwriter";
else if (-1!=mountPoint().find("mo",0,FALSE)) iconName+="mo";
else if (-1!=deviceName().find("mo",0,FALSE)) iconName+="mo";
else if (-1!=deviceName().find("fd",0,FALSE)) {
if (-1!=deviceName().find("360",0,FALSE)) iconName+="5floppy";
if (-1!=deviceName().find("1200",0,FALSE)) iconName+="5floppy";
else iconName+="3floppy";
}
else if (-1!=mountPoint().find("floppy",0,FALSE)) iconName+="3floppy";
else if (-1!=mountPoint().find("zip",0,FALSE)) iconName+="zip";
else if (-1!=fsType().find("nfs",0,FALSE)) iconName+="nfs";
else iconName+="hdd";
mounted() ? iconName+="_mount" : iconName+="_unmount";
// if ( -1==mountOptions().find("user",0,FALSE) )
// iconName.prepend("root_"); // special root icon, normal user canīt mount
//debug("device %s is %s",deviceName().latin1(),iconName.latin1());
//emit iconNameChanged();
return iconName;
};
/***************************************************************************
* starts a command on the underlying system via /bin/sh
**/
kdf'DiskEntry::sysCall() (./kdeutils/kdf/disks.cpp:217)
int DiskEntry::sysCall(QString command)
{
debug("DiskEntry::sysCall");
if (readingSysStdErrOut || sysProc->isRunning() ) return -1;
sysStringErrOut=i18n("Called: %1\n\n").arg(command); // put the called command on ErrOut
sysProc->clearArguments();
(*sysProc) << (const char *)command;
if (!sysProc->start( KProcess::Block, KProcess::AllOutput ))
fatal(i18n("could not execute [%s]"),(const char *)command);
debug("DiskEntry::sysCall sysProc->normaleExit=%d", sysProc->normalExit());
if (sysProc->exitStatus()!=0) emit sysCallError(this, sysProc->exitStatus());
debug("DiskEntry::sysCall sysProc->exitStatus=%d", sysProc->exitStatus() );
return !sysProc->exitStatus();
};
/***************************************************************************
* is called, when the Sys-command writes on StdOut or StdErr
**/
kdf'DiskEntry::receivedSysStdErrOut() (./kdeutils/kdf/disks.cpp:239)
void DiskEntry::receivedSysStdErrOut(KProcess *, char *data, int len)
{
debug("DiskEntry::receivedSysStdErrOut");
QString tmp = QString(data) + QString("\0"); // adds a zero-byte
tmp.truncate(len);
sysStringErrOut.append(tmp);
};
kdf'DiskEntry::prettyPrint() (./kdeutils/kdf/disks.cpp:247)
QString DiskEntry::prettyPrint(int kBValue) const
{
QString weight;
float val=(float)kBValue; // size in KiloByte
//always go up to MegaByte
val=val/1024;
weight="MB";
if (val>999.0) { //GigaByte
val=val/1024;
weight="GB";
}//if
QString ret;
if (val>100.0) // e.g. 504MB
ret.sprintf("%3.0f%s",val,(const char *)weight);
else
if (val>10.0) // e.g. 54.7MB
ret.sprintf("%3.1f%s",val,(const char *)weight);
else // e.g. 1.44KB
ret.sprintf("%3.2f%s",val,(const char *)weight);
return ret;
}
kdf'DiskEntry::percentFull() (./kdeutils/kdf/disks.cpp:272)
float DiskEntry::percentFull() const
{
if (size != 0) {
return 100 - ( ((float)avail / (float)size) * 100 );
} else {
return -1;
}
}
kdf'DiskEntry::setDeviceName() (./kdeutils/kdf/disks.cpp:281)
void DiskEntry::setDeviceName(QString deviceName)
{
device=deviceName;
emit deviceNameChanged();
};
kdf'DiskEntry::setMountPoint() (./kdeutils/kdf/disks.cpp:287)
void DiskEntry::setMountPoint(QString mountPoint)
{
mountedOn=mountPoint;
emit mountPointChanged();
};
kdf'DiskEntry::setMountOptions() (./kdeutils/kdf/disks.cpp:293)
void DiskEntry::setMountOptions(QString mountOptions)
{
options=mountOptions;
emit mountOptionsChanged();
};
kdf'DiskEntry::setFsType() (./kdeutils/kdf/disks.cpp:299)
void DiskEntry::setFsType(QString fsType)
{
type=fsType;
emit fsTypeChanged();
};
kdf'DiskEntry::setMounted() (./kdeutils/kdf/disks.cpp:305)
void DiskEntry::setMounted(bool nowMounted)
{
isMounted=nowMounted;
emit mountedChanged();
};
kdf'DiskEntry::setKBSize() (./kdeutils/kdf/disks.cpp:311)
void DiskEntry::setKBSize(int kb_size)
{
debug("DiskEntry::setKBSize(%d)",kb_size);
size=kb_size;
emit kBSizeChanged();
};
kdf'DiskEntry::setKBUsed() (./kdeutils/kdf/disks.cpp:318)
void DiskEntry::setKBUsed(int kb_used)
{
debug("DiskEntry::setKBUsed(%d)",kb_used);
used=kb_used;
if ( size < (used+avail) ) { //adjust kBAvail
warning("device %s: kBAvail(%d)+*kBUsed(%d) exceeds kBSize(%d)"
,(const char *)device,avail,used,size);
setKBAvail(size-used);
}
emit kBUsedChanged();
};
kdf'DiskEntry::setKBAvail() (./kdeutils/kdf/disks.cpp:330)
void DiskEntry::setKBAvail(int kb_avail)
{
debug("DiskEntry::setKBAvail(%d)",kb_avail);
avail=kb_avail;
if ( size < (used+avail) ) { //adjust kBUsed
warning("device %s: *kBAvail(%d)+kBUsed(%d) exceeds kBSize(%d)"
,(const char *)device,avail,used,size);
setKBUsed(size-avail);
}
emit kBAvailChanged();
};