bool MediaImpl::statMedium(const QString &name, KIO::UDSEntry &entry)
{
kdDebug(1219) << "MediaImpl::statMedium: " << name << endl;
DCOPRef mediamanager("kded", "mediamanager");
DCOPReply reply = mediamanager.call("properties", name);
if(!reply.isValid())
{
m_lastErrorCode = KIO::ERR_SLAVE_DEFINED;
m_lastErrorMessage = i18n("The KDE mediamanager is not running.");
return false;
}
Medium m = Medium::create(reply);
if(m.id().isEmpty())
{
entry.clear();
return false;
}
createMediumEntry(entry, m);
return true;
}
void
MediumPluginManager::newDevice()
{
DEBUG_BLOCK
ManualDeviceAdder* mda = new ManualDeviceAdder( this );
if( mda->exec() == QDialog::Accepted && mda->successful() && mda->getMedium() != 0 )
{
if( amaroK::config( "MediaBrowser" )->readEntry( mda->getMedium()->id() ) != QString::null )
{
//abort! Can't have the same device defined twice...should never
//happen due to name checking earlier...right?
amaroK::StatusBar::instance()->longMessageThreadSafe( i18n("Sorry, you cannot define two devices\n"
"with the same name and mountpoint!") );
}
else
{
Medium *newdev = mda->getMedium();
amaroK::config( "MediaBrowser" )->writeEntry( newdev->id(), mda->getPlugin() );
DeviceManager::instance()->addManualDevice( newdev );
m_newDevMap[newdev->id()] = newdev;
detectDevices();
}
}
delete mda;
slotChanged();
}
bool RemovableBackend::plug(const QString &devNode, const QString &label)
{
QString name = generateName(devNode);
QString id = generateId(devNode);
if(!m_removableIds.contains(id))
{
Medium *medium = new Medium(id, name);
medium->mountableState(devNode, QString::null, QString::null, false);
QStringList words = QStringList::split(" ", label);
QStringList::iterator it = words.begin();
QStringList::iterator end = words.end();
QString tmp = (*it).lower();
tmp[0] = tmp[0].upper();
QString new_label = tmp;
++it;
for(; it != end; ++it)
{
tmp = (*it).lower();
tmp[0] = tmp[0].upper();
new_label += " " + tmp;
}
medium->setLabel(new_label);
medium->setMimeType("media/removable_unmounted");
m_removableIds.append(id);
return !m_mediaList.addMedium(medium).isNull();
}
return false;
}
void Scene::load_media(const string& filename)
{
Medium air;
air.get_ior(mono).resize(1);
air.get_ior(mono)[0] = complex<double>(1.0, 0.0);
air.fill_rgb_data();
air.name = "default";
set_medium(air);
for(unsigned int i = 0; i < planes.size(); ++i)
meshes.push_back(planes[i]->get_mesh());
load_mpml(filename, media, interfaces);
for(unsigned int i = 0; i < meshes.size(); ++i)
for(unsigned int j = 0; j < meshes[i]->materials.size(); ++j)
{
const ObjMaterial& mat = meshes[i]->materials[j];
string name = mat.name;
Interface& iface = interfaces[name];
if(!iface.med_in)
{
iface.name = name;
iface.med_in = &media[name];
iface.med_in->name = name;
Color< complex<double> >& ior = iface.med_in->get_ior(mono);
ior.resize(1);
ior[0] = complex<double>(mat.ior, 0.0);
float emissive = 0.0f;
for(unsigned int k = 0; k < 3; ++k)
emissive += mat.ambient[k];
if(emissive > 0.0)
{
iface.med_in->emissive = true;
Color<double>& emission = iface.med_in->get_emission(rgb);
emission.resize(3);
for(unsigned int k = 0; k < emission.size(); ++k)
emission[k] = mat.ambient[k];
}
}
iface.med_in->fill_rgb_data();
iface.med_in->fill_mono_data();
if(iface.med_out)
{
iface.med_out->fill_rgb_data();
iface.med_out->fill_mono_data();
}
if(mat.has_texture)
{
Texture*& tex = textures[mat.tex_name];
tex = new Texture;
string path_and_name = mat.tex_path + mat.tex_name;
tex->load(path_and_name.c_str());
}
}
for(unsigned int i = 0; i < planes.size(); ++i)
meshes.pop_back();
}
void Tag::write_disc(const Release &release, const Medium &medium) {
if (release.is_multidisc()) {
set("DISCNUMBER", medium.get_position());
set("TOTALDISCS", release.get_medium_total_count());
set("DISCSUBTITLE", medium.get_title());
} else {
unset("DISCNUMBER");
unset("TOTALDISCS");
unset("DISCSUBTITLE");
}
}
void PhotonMappingRenderer::CastGlobalPhoton(Scenery& scenery,
MultispectralPhoton& photon,
bool direct, int depth,
Object* last_object_hit) {
if(depth <= 0)
return;
//Computing nearest intersection
Real distance = -1;
Object* nearest_object = 0;
Point intersection;
//If there is no intersection photon is lost
Ray ray;
ray.v = photon.direction;
ray.o = photon.position;
Basis local_basis;
Point2D surface_coordinate;
if(!scenery.getNearestIntersection(ray, distance, nearest_object,
local_basis, surface_coordinate,
last_object_hit))
return;
//Adding photon to global map
photon.position = local_basis.o;
photon.distance = distance * m_scale;
photon.normal = local_basis.k;
//Compute medium absorption
Medium* medium = 0;
if(photon.direction.dot(local_basis.k) < 0) {
medium = nearest_object->getOuterMedium();
} else {
medium = nearest_object->getInnerMedium();
}
if(!medium->transportPhoton(photon))
return;
if(!direct || m_nb_samples > 0) {
if(photon.direction.dot(local_basis.k) < 0) {
m_global_map_out[nearest_object->getIndex()]->addPhoton(photon);
} else {
m_global_map_in[nearest_object->getIndex()]->addPhoton(photon);
}
}
//Photon bounce
bool specular;
if(nearest_object->bouncePhoton(local_basis, surface_coordinate,
photon, specular)) {
CastGlobalPhoton(scenery, photon, false, depth - 1, nearest_object);
}
}
bool MediaImpl::ensureMediumMounted(Medium &medium)
{
if(medium.id().isEmpty())
{
m_lastErrorCode = KIO::ERR_COULD_NOT_MOUNT;
m_lastErrorMessage = i18n("No such medium.");
return false;
}
if(medium.needMounting())
{
m_lastErrorCode = 0;
mp_mounting = &medium;
/*
KIO::Job* job = KIO::mount(false, 0,
medium.deviceNode(),
medium.mountPoint());
job->setAutoWarningHandlingEnabled(false);
connect( job, SIGNAL( result( KIO::Job * ) ),
this, SLOT( slotMountResult( KIO::Job * ) ) );
connect( job, SIGNAL( warning( KIO::Job *, const QString & ) ),
this, SLOT( slotWarning( KIO::Job *, const QString & ) ) );
*/
kapp->dcopClient()->connectDCOPSignal("kded", "mediamanager", "mediumChanged(QString, bool)", "mediaimpl", "slotMediumChanged(QString)",
false);
DCOPRef mediamanager("kded", "mediamanager");
DCOPReply reply = mediamanager.call("mount", medium.id());
if(reply.isValid())
reply.get(m_lastErrorMessage);
else
m_lastErrorMessage = i18n("Internal Error");
if(!m_lastErrorMessage.isEmpty())
m_lastErrorCode = KIO::ERR_SLAVE_DEFINED;
else
{
qApp->eventLoop()->enterLoop();
}
mp_mounting = 0L;
kapp->dcopClient()->disconnectDCOPSignal("kded", "mediamanager", "mediumChanged(QString, bool)", "mediaimpl", "slotMediumChanged(QString)");
return m_lastErrorCode == 0;
}
return true;
}
bool MediaImpl::realURL(const QString &name, const QString &path, KURL &url)
{
bool ok;
Medium m = findMediumByName(name, ok);
if(!ok)
return false;
ok = ensureMediumMounted(m);
if(!ok)
return false;
url = m.prettyBaseURL();
url.addPath(path);
return true;
}
Boolean MediaSink::lookupByName(UsageEnvironment& env, char const* sinkName,
MediaSink*& resultSink) {
resultSink = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, sinkName, medium)) return False;
if (!medium->isSink()) {
env.setResultMsg(sinkName, " is not a media sink");
return False;
}
resultSink = (MediaSink*)medium;
return True;
}
Boolean DarwinInjector::lookupByName(UsageEnvironment& env, char const* name,
DarwinInjector*& result) {
result = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, name, medium)) return False;
if (!medium->isDarwinInjector()) {
env.setResultMsg(name, " is not a 'Darwin injector'");
return False;
}
result = (DarwinInjector*)medium;
return True;
}
Boolean MediaSession::lookupByName(UsageEnvironment& env,
char const* instanceName,
MediaSession*& resultSession) {
resultSession = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, instanceName, medium)) return False;
if (!medium->isMediaSession()) {
env.setResultMsg(instanceName, " is not a 'MediaSession' object");
return False;
}
resultSession = (MediaSession*)medium;
return True;
}
Boolean MediaSource::lookupByName(UsageEnvironment& env,
char const* sourceName,
MediaSource*& resultSource) {
resultSource = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, sourceName, medium)) return False;
if (!medium->isSource()) {
env.setResultMsg(sourceName, " is not a media source");
return False;
}
resultSource = (MediaSource*)medium;
return True;
}
Boolean RTSPServer::lookupByName(UsageEnvironment& env,
char const* name,
RTSPServer*& resultServer) {
resultServer = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, name, medium)) return False;
if (!medium->isRTSPServer()) {
env.setResultMsg(name, " is not a RTSP server");
return False;
}
resultServer = (RTSPServer*)medium;
return True;
}
Boolean RTCPInstance::lookupByName(UsageEnvironment& env,
char const* instanceName,
RTCPInstance*& resultInstance) {
resultInstance = NULL; // unless we succeed
Medium* medium;
if (!Medium::lookupByName(env, instanceName, medium)) return False;
if (!medium->isRTCPInstance()) {
env.setResultMsg(instanceName, " is not a RTCP instance");
return False;
}
resultInstance = (RTCPInstance*)medium;
return True;
}
/*
* distribute routes to active interfaces like the
* TRIP linecards
*/
void
ipifcaddroute(Fs *f, int vers, uchar *addr, uchar *mask, uchar *gate, int type)
{
Medium *m;
Conv **cp, **e;
Ipifc *ifc;
e = &f->ipifc->conv[f->ipifc->nc];
for(cp = f->ipifc->conv; cp < e; cp++){
if(*cp != nil) {
ifc = (Ipifc*)(*cp)->ptcl;
m = ifc->m;
if(m && m->addroute)
m->addroute(ifc, vers, addr, mask, gate, type);
}
}
}
void
ipifcremroute(Fs *f, int vers, uint8_t *addr, uint8_t *mask)
{
Medium *m;
Conv **cp, **e;
Ipifc *ifc;
e = &f->ipifc->conv[f->ipifc->nc];
for(cp = f->ipifc->conv; cp < e; cp++){
if(*cp != nil) {
ifc = (Ipifc*)(*cp)->ptcl;
m = ifc->medium;
if(m && m->remroute)
m->remroute(ifc, vers, addr, mask);
}
}
}
Medium*
ManualDeviceAdder::getMedium()
{
if( m_mdaMountPoint->isEnabled() == false &&
m_mdaName->text() == QString::null )
return NULL;
if( m_mdaMountPoint->text() == QString::null &&
m_mdaName->text() == QString::null )
return NULL;
QString id = "manual|" + m_mdaName->text() + '|' +
( m_mdaMountPoint->text() == QString::null ||
m_mdaMountPoint->isEnabled() == false ?
"(null)" : m_mdaMountPoint->text() );
Medium* added = new Medium( id, m_mdaName->text() );
added->setAutodetected( false );
added->setMountPoint( m_mdaMountPoint->text() );
return added;
}
Medium water(double T, double S)
{
static const double M_4PI = 4.0*M_PI;
Medium m;
Color< complex<double> >& ior = m.get_ior(spectrum);
ior.resize(no_of_samples);
ior.wavelength = first_wavelength;
ior.step_size = wavelength_step_size;
for(unsigned int i = 0; i < ior.size(); ++i)
{
double lambda = ior.wavelength + i*ior.step_size;
double Psi_T = TS_correction[i][0];
double Psi_S = TS_correction[i][1];
double ior_imag = ior_imag_part[i] + lambda*((T - 22)*Psi_T + S*Psi_S)/M_4PI;
ior[i] = complex<double>(water_ior_real_part(lambda, T, S), ior_imag);
}
m.name = "water";
return m;
}
void MediaImpl::createMediumEntry(KIO::UDSEntry &entry, const Medium &medium)
{
kdDebug(1219) << "MediaProtocol::createMedium" << endl;
QString url = "media:/" + medium.name();
kdDebug(1219) << "url = " << url << ", mime = " << medium.mimeType() << endl;
entry.clear();
addAtom(entry, KIO::UDS_URL, 0, url);
QString label = KIO::encodeFileName(medium.prettyLabel());
addAtom(entry, KIO::UDS_NAME, 0, label);
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, medium.mimeType());
addAtom(entry, KIO::UDS_GUESSED_MIME_TYPE, 0, "inode/directory");
if(!medium.iconName().isEmpty())
{
addAtom(entry, KIO::UDS_ICON_NAME, 0, medium.iconName());
}
else
{
QString mime = medium.mimeType();
QString icon = KMimeType::mimeType(mime)->icon(mime, false);
addAtom(entry, KIO::UDS_ICON_NAME, 0, icon);
}
if(medium.needMounting())
{
addAtom(entry, KIO::UDS_ACCESS, 0400);
}
else
{
KURL url = medium.prettyBaseURL();
entry += extractUrlInfos(url);
}
}
void Tag::write_musicbrainz_ids(const Release &release, const Medium &medium, const Track &track) {
if (Preferences::write_ids) {
set("MUSICBRAINZ_ALBUMID", release.get_id());
set("MUSICBRAINZ_RELEASEGROUPID", release.get_release_group()->get_id());
set("MUSICBRAINZ_TRACKID", track.get_id());
set("MUSICBRAINZ_ARTISTID", track.get_artist_credit()->get_ids());
if (release.is_various()) {
set("MUSICBRAINZ_ALBUMARTISTID", release.get_artist_credit()->get_ids());
} else {
unset("MUSICBRAINZ_ALBUMARTISTID");
}
auto discid = medium.get_discid();
if (!discid.is_empty()) {
set("MUSICBRAINZ_DISCID", discid);
}
}
}
int main(int argc, char** argv) {
using namespace std;
void (*work)(Medium*);
work = print;
Medium *a = new Audio("Bryan Adams", 222);
a->setTitel("Summer of 69");
a->setJahr(1993);
Medium *b = new Bild("London");
b->setTitel("Abbey Road");
b->setJahr(1962);
LinkedList<Medium*> liste;
liste.append(b);
liste.insert(a, 2);
LinkedList<Medium*> liste2 = liste;
cout << "Liste:" << endl;
// liste.visit_all(work);
liste.visit_all(print);
liste.remove(2);
cout << "Liste: " << endl;
liste.visit_all(work);
cout << "Liste2: " << endl;
liste2.visit_all(work);
return 0;
}
void Tag::write_general(const Release &release, const Medium &medium, const Track &track) {
set("ALBUM", release.get_title());
set("TITLE", track.get_title());
set("TRACKNUMBER", track.get_position());
set("TOTALTRACKS", medium.track_count());
}
bool KFileMediaPlugin::readInfo(KFileMetaInfo &info, uint /*what*/)
{
const Medium medium = askMedium(info);
kdDebug() << "KFileMediaPlugin::readInfo " << medium.id() << endl;
if (medium.id().isNull()) return false;
QString mount_point = medium.mountPoint();
KURL base_url = medium.prettyBaseURL();
QString device_node = medium.deviceNode();
KFileMetaInfoGroup group = appendGroup(info, "mediumInfo");
if (base_url.isValid())
{
appendItem(group, "baseURL", base_url.prettyURL());
}
if (!device_node.isEmpty())
{
appendItem(group, "deviceNode", device_node);
}
if (!mount_point.isEmpty() && medium.isMounted())
{
m_total = 0;
m_used = 0;
m_free = 0;
struct statvfs vfs;
memset(&vfs, 0, sizeof(vfs));
if ( ::statvfs(QFile::encodeName(mount_point), &vfs) != -1 )
{
m_total = static_cast<KIO::filesize_t>(vfs.f_blocks) * static_cast<KIO::filesize_t>(vfs.f_frsize);
m_free = static_cast<KIO::filesize_t>(vfs.f_bavail) * static_cast<KIO::filesize_t>(vfs.f_frsize);
m_used = m_total - m_free;
int percent = 0;
int length = 0;
if (m_total != 0)
{
percent = 100 * m_used / m_total;
length = 150 * m_used / m_total;
}
appendItem(group, "free", m_free);
appendItem(group, "used", m_used);
appendItem(group, "total", m_total);
group = appendGroup(info, "mediumSummary");
appendItem(group, "percent", QString("%1%").arg(percent));
QPixmap bar(150, 20);
QPainter p(&bar);
p.fillRect(0, 0, length, 20, Qt::red);
p.fillRect(length, 0, 150-length, 20, Qt::green);
QColorGroup cg = QApplication::palette().active();
QApplication::style().drawPrimitive(QStyle::PE_Panel, &p,
QRect(0, 0, 150, 20), cg,
QStyle::Style_Sunken);
appendItem( group, "thumbnail", bar );
}
}
return true;
}
int main() {
clock_t start, end;
Introduction();
int Time_Selection = ChooseSteadyOrTime(); // 1 for steady state, 2 for time resolved
numPhotons = HowManyPhotons();
start = clock();
Medium * m = new Medium;
Heat * h = new Heat;
// inserting brain layers
m->CreateCube(0, 0, 0, 10, 10, 10, 0.07, 37.4, 0.977, 1.37); // adipose tissue @ 700 nm
//m->CreateBall(1,1,1,1,0.02,9.0,0.89,1.37);
m->CreateCube(1, 1, 0, 8, 8, 8, 0.15, 1.67, 0.7, 1.37); // AuNR in intralipid
m->CreateCube(2, 2, 2, 6, 6, 6, 0.045, 29.5, 0.96, 1.37); // breast carcinoma @ 700nm
//m->CreateCube(6, 6, 6, 2, 2, 2, 0.08, 40.9, 0.84, 1.37); // white-matter
h->AddThermalCoef(m, 2, 3.800, 0.001000, 0.000500, 0); // spinus
h->AddThermalCoef(m, 1, 1.590, 0.001520, 0.000650, 0); // bone
h->AddThermalCoef(m, 3, 3.680, 0.001030, 0.000565, 0); // grey-matter
// h->AddThermalCoef(m, 4, 3.600, 0.001030, 0.000505); // white-matter
//m->PrintMediumProperties();
Source * s1 = new Source;
// for(long i = 0; i < numPhotons; i++)
// RunPhotonNew(m, s);
if (Time_Selection == 2)
{
for (long i = 0; i < numThreads; i++)
{
myThreads[i] = thread(CreateNewThread_time, m, s1, (long)floor(numPhotons / numThreads));
}
for (long i = 0; i < numThreads; i++)
{
myThreads[i].join();
}
m->RescaleEnergy_Time(numPhotons, time_step);
WriteAbsorbedEnergyToFile_Time(m);
}
else
{
for (long i = 0; i < numThreads; i++)
{
myThreads[i] = thread(CreateNewThread_steady, m, s1, (long)floor(numPhotons / numThreads));
}
for (long i = 0; i < numThreads; i++)
{
myThreads[i].join();
}
m->RescaleEnergy(numPhotons);
WriteAbsorbedEnergyToFile(m);
h->PennesEquation(m,35);
WriteTemperature(m, h);
}
// Run second pulse
Source * s2 = new Source;
/*Prepare_SecondPulse(m, s2, 0.1);
for (long i = 0; i < numThreads; i++)
{
myThreads[i] = thread(CreateNewThread_secondPulse, m, s2, (long)floor(numPhotons / numThreads));
}
for (long i = 0; i < numThreads; i++)
{
myThreads[i].join();
}*/
//m->RecordFluence();
// WritePhotonFluenceToFile(m);
/*m->RescaleEnergy_Time_secondPulse(numPhotons, time_step);
WriteAbsorbedEnergyToFile_Time_secondPulse(m);*/
delete m;
delete s1; delete s2;
delete h;
end = clock();
cout << "Simulation duration was " << (float)(end - start) / CLOCKS_PER_SEC << " seconds." << endl;
system("pause");
exit(0);
}
/**
* @brief MainWindow::addMedium fügt ein Medium in die Datenbank und ins UI ein
* @param mType Typ des Mediums
* @param mName Titel des Mediums
* @param mID ID des Mediums, falls verfügbar (wenn leer, dann wird eine eigene erstellt)
* @return ID des eingefügten Mediums
*/
int MainWindow::addMedium(MType mType, QString mName, QString detail, int mID){
QString mTypeString;
QString mEntry;
Medium *medium;
QString detailType;
/// Unterscheidung zwischen Medien Typ: erstellt verschieden Klassen und füllt die Zusatzinformationen
switch (mType){
case book:
mTypeString="Buch";
medium = new Book(mName);
((Book*)medium)->setAuthor(detail);
detailType="Autor: ";
break;
case cd:
mTypeString="CD";
medium = new CD(mName);
((CD*)medium)->setInterpret(detail);
detailType="Interpret: ";
break;
case dvd:
mTypeString="DVD";
medium = new DVD(mName);
((DVD*)medium)->setDirector(detail);
detailType="Regisseur: ";
break;
default:
mTypeString="-";
medium = new Medium(mName);
}
if (detail.isEmpty()){
detail = "-";
detailType = "";
}
/// Medium in Datenbank erfassen (Fehler, falls ID bereits existiert)
if (mID == -1){
lendlib->addMediumToList(medium);
} else {
if (!lendlib->addMediumToList(medium, mID)){
otherErr = true;
errString = "Medium konnte nicht mit vorgegebener ID eingegeben werden.";
checkError();
}
}
mEntry = QString::number(medium->getID());
/// UI-Elemente erstellen
QWidget *newMedium = new QWidget;
QHBoxLayout *newMediumLayout = new QHBoxLayout(newMedium);
QPushButton *delB = new QPushButton("Löschen");
QLabel *type = new QLabel(mTypeString);
QLabel *title = new QLabel(mName);
QLabel *lendee = new QLabel("");
QPushButton *retlendB = new QPushButton("Ausleihen");
/// UI-Eigenschaften anpassen
newMedium->setObjectName(mEntry);
newMedium->setToolTip("Typ: "+mTypeString+"\nTitel: "+mName+"\n"+detailType+detail);
delB->setObjectName("del"+mEntry);
delB->setToolTip("Lösche Medium "+mEntry+": "+mName);
type->setObjectName("type"+mEntry);
title->setObjectName("title"+mEntry);
lendee->setObjectName("lendee"+mEntry);
retlendB->setObjectName("retlend"+mEntry);
retlendB->setToolTip("Leihe Medium "+mEntry+" aus: "+mName);
newMedium->layout()->setMargin(0);
newMedium->setStyleSheet("border-bottom: 1px solid #DEE2CF");
delB->setStyleSheet("background: #DEE2CF;");
delB->setMinimumWidth(60);
delB->setMaximumWidth(60);
delB->setMinimumHeight(25);
delB->setMaximumHeight(25);
connect(delB, SIGNAL (released()), this, SLOT (deleteMediumButton()));
retlendB->setStyleSheet("background: #DEE2CF;");
retlendB->setMinimumWidth(100);
retlendB->setMaximumWidth(100);
retlendB->setMinimumHeight(25);
retlendB->setMaximumHeight(25);
connect(retlendB, SIGNAL (released()), this, SLOT (retlendMediumButton()));
type->setMinimumWidth(60);
type->setMaximumWidth(60);
lendee->setMinimumWidth(100);
lendee->setMaximumWidth(100);
newMediumLayout->addWidget(delB);
newMediumLayout->addWidget(type);
newMediumLayout->addWidget(title);
newMediumLayout->addWidget(lendee);
newMediumLayout->addWidget(retlendB);
qobject_cast<QVBoxLayout*>(ui->allMediaScroll->layout())->insertWidget(getInsertPosition(mName),newMedium);
ui->allMediaScroll->layout()->removeItem(ui->mediaSpacer);
ui->allMediaScroll->layout()->addItem(ui->mediaSpacer);
return medium->getID();
}
DeviceConfigureDialog::DeviceConfigureDialog( const Medium &medium )
: KDialogBase( amaroK::mainWindow(), "deviceconfiguredialog", true, QString("Select Plugin for " + medium.name()), Ok|Cancel, Ok, false )
{
m_medium = new Medium( medium );
kapp->setTopWidget( this );
setCaption( kapp->makeStdCaption( i18n( "Configure Media Device" ) ) );
showButtonApply( false );
QVBox* vbox = makeVBoxMainWidget();
vbox->setSpacing( KDialog::spacingHint() );
QLabel *connectLabel = 0;
m_connectEdit = 0;
QLabel *disconnectLabel = 0;
m_disconnectEdit = 0;
m_transcodeCheck = 0;
QButtonGroup *transcodeGroup = 0;
m_transcodeAlways = 0;
m_transcodeWhenNecessary = 0;
m_transcodeRemove = 0;
MediaDevice* device = MediaBrowser::instance()->deviceFromId( m_medium->id() );
if( device )
{
device->loadConfig();
// pre-connect/post-disconnect (mount/umount)
connectLabel = new QLabel( vbox );
connectLabel->setText( i18n( "Pre-&connect command:" ) );
m_connectEdit = new HintLineEdit( device->m_preconnectcmd, vbox );
m_connectEdit->setHint( i18n( "Example: mount %d" ) );
connectLabel->setBuddy( m_connectEdit );
QToolTip::add( m_connectEdit, i18n( "Set a command to be run before connecting to your device (e.g. a mount command) here.\n%d is replaced by the device node, %m by the mount point.\nEmpty commands are not executed." ) );
disconnectLabel = new QLabel( vbox );
disconnectLabel->setText( i18n( "Post-&disconnect command:" ) );
m_disconnectEdit = new HintLineEdit( device->m_postdisconnectcmd, vbox );
disconnectLabel->setBuddy( m_disconnectEdit );
m_disconnectEdit->setHint( i18n( "Example: eject %d" ) );
QToolTip::add( m_disconnectEdit, i18n( "Set a command to be run after disconnecting from your device (e.g. an eject command) here.\n%d is replaced by the device node, %m by the mount point.\nEmpty commands are not executed." ) );
// transcode
m_transcodeCheck = new QCheckBox( vbox );
m_transcodeCheck->setText( i18n( "&Transcode before transferring to device" ) );
m_transcodeCheck->setChecked( device->m_transcode );
transcodeGroup = new QVButtonGroup( vbox );
transcodeGroup->setTitle( i18n( "Transcode to preferred format for device" ) );
m_transcodeAlways = new QRadioButton( transcodeGroup );
m_transcodeAlways->setText( i18n( "Whenever possible" ) );
m_transcodeAlways->setChecked( device->m_transcodeAlways );
m_transcodeWhenNecessary = new QRadioButton( transcodeGroup );
m_transcodeWhenNecessary->setText( i18n( "When necessary" ) );
m_transcodeWhenNecessary->setChecked( !device->m_transcodeAlways );
connect( m_transcodeCheck, SIGNAL(toggled( bool )),
transcodeGroup, SLOT(setEnabled( bool )) );
transcodeGroup->insert( m_transcodeAlways );
transcodeGroup->insert( m_transcodeWhenNecessary );
m_transcodeRemove = new QCheckBox( transcodeGroup );
m_transcodeRemove->setText( i18n( "Remove transcoded files after transfer" ) );
m_transcodeRemove->setChecked( device->m_transcodeRemove );
const ScriptManager *sm = ScriptManager::instance();
m_transcodeCheck->setEnabled( sm->transcodeScriptRunning() != QString::null );
transcodeGroup->setEnabled( sm->transcodeScriptRunning() != QString::null && device->m_transcode );
if( sm->transcodeScriptRunning().isNull() )
{
QToolTip::add( m_transcodeCheck, i18n( "For this feature, a script of type \"Transcode\" has to be running" ) );
QToolTip::add( transcodeGroup, i18n( "For this feature, a script of type \"Transcode\" has to be running" ) );
}
device->addConfigElements( vbox );
}
m_accepted = false;
}
