TDE
/
tderadio
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tderadio
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
tderadio/plugins/radio/radio-configuration.cpp

593 lines
18 KiB
Raw Permalink Blame History

/***************************************************************************
radio-configuration.cpp - description
-------------------
begin : Son Aug 3 2003
copyright : (C) 2003 by Martin Witte
email : witte@kawo1.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "../../src/include/radiostation.h"
#include "../../src/include/stationlist.h"
#include "../../src/include/plugins.h"
#include "../../src/include/radiodevice_interfaces.h"
#include "../../src/include/standardscandialog.h"
#include "../../src/include/radiostation-listview.h"
#include "../../src/include/radiostation-config.h"
#include "../../src/include/errorlog-interfaces.h"
#include "radio-configuration.h"
#include <math.h>
#include <tqlistbox.h>
#include <tdelistbox.h>
#include <tqdatetimeedit.h>
#include <tqlineedit.h>
#include <tqlabel.h>
#include <tqspinbox.h>
#include <tqpushbutton.h>
#include <tqpopupmenu.h>
#include <tqtoolbutton.h>
#include <tqwidgetstack.h>
#include <tqimage.h>
#include <tdefiledialog.h>
#include <kstandarddirs.h>
#include <kurllabel.h>
#include <tqregexp.h>
#include <krun.h>
#include <kurlrequester.h>
#include <tdelocale.h>
RadioConfiguration::RadioConfiguration (TQWidget *parent, const IErrorLogClient &logger)
: RadioConfigurationUI(parent),
ignoreChanges(false),
devicePopup(NULL),
m_logger(logger),
m_dirty(true)
{
TQObject::connect(listStations, TQ_SIGNAL(sigCurrentStationChanged(int)),
this, TQ_SLOT(slotStationSelectionChanged(int)));
TQObject::connect(buttonSelectPixmapFile, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSelectPixmap()));
TQObject::connect(buttonNewStation, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotNewStation()));
TQObject::connect(buttonDeleteStation, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteStation()));
TQObject::connect(editPixmapFile, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotPixmapChanged(const TQString &)));
TQObject::connect(editStationName, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotStationNameChanged(const TQString &)));
TQObject::connect(editStationShortName, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotStationShortNameChanged(const TQString &)));
TQObject::connect(editVolumePreset, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotVolumePresetChanged(int)));
TQObject::connect(buttonStationUp, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotStationUp()));
TQObject::connect(buttonStationDown, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotStationDown()));
TQObject::connect(listStations, TQ_SIGNAL(sigStationActivated(int)),
this, TQ_SLOT(slotActivateStation( int )));
TQObject::connect(buttonLoadPresets, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotLoadPresets()));
TQObject::connect(buttonStorePresets, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotStorePresets()));
TQObject::connect(buttonLastChangeNow, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotLastChangeNow()));
connect(editMaintainer, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
connect(editLastChange, TQ_SIGNAL(valueChanged(const TQDateTime &)), TQ_SLOT(slotSetDirty()));
connect(editCountry, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
connect(editCity, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
connect(editMedia, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
connect(editComment, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
connect(editPresetFile, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(slotSetDirty()));
mailLabel->setText("mailto:witte-presets@kawo1.rwth-aachen.de");
mailLabel->setURL ("mailto:witte-presets@kawo1.rwth-aachen.de");
TQObject::connect(mailLabel, TQ_SIGNAL(leftClickedURL(const TQString &)),
this, TQ_SLOT(slotSendPresetsByMail(const TQString &)));
TQObject::connect(buttonSearchStations, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSearchStations0()));
devicePopup = new TQPopupMenu(buttonSearchStations);
buttonSearchStations->setPopup(devicePopup);
TQObject::connect(devicePopup, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSearchStations(int)));
}
RadioConfiguration::~RadioConfiguration ()
{
}
bool RadioConfiguration::connectI (Interface *i)
{
bool a = IRadioClient::connectI(i);
bool b = IRadioDevicePoolClient::connectI(i);
return a || b;
}
bool RadioConfiguration::disconnectI (Interface *i)
{
bool a = IRadioClient::disconnectI(i);
bool b = IRadioDevicePoolClient::disconnectI(i);
return a || b;
}
// IRadioDevicePoolClient
bool RadioConfiguration::noticeDevicesChanged(const TQPtrList<IRadioDevice> &l)
{
TQPtrListIterator<IRadioDevice> it(l);
devices.clear();
devicePopup->clear();
int id = 0;
for (; it.current(); ++it) {
IRadioDevice *d = it.current();
if (dynamic_cast<ISeekRadio*>(d)) {
devicePopup->insertItem(d->getDescription(), id++);
devices.append(d);
}
}
return true;
}
bool RadioConfiguration::noticeDeviceDescriptionChanged(const TQString &)
{
noticeDevicesChanged(queryDevices());
return true;
}
// IRadioClient
bool RadioConfiguration::noticeStationsChanged(const StationList &sl)
{
ignoreChanges = true;
m_stations = sl;
listStations->setStations(sl);
StationListMetaData &info = m_stations.metaData();
editMaintainer->setText(info.maintainer);
editLastChange->setDateTime(info.lastChange);
editCountry->setText(info.country);
editCity->setText(info.city);
editMedia->setText(info.media);
editComment->setText(info.comment);
ignoreChanges = false;
slotStationSelectionChanged(listStations->currentStationIndex());
return true;
}
bool RadioConfiguration::noticePresetFileChanged(const TQString &f)
{
ignoreChanges = true;
editPresetFile->setURL(f);
ignoreChanges = false;
return true;
}
void RadioConfiguration::slotStationSelectionChanged(int idx)
{
RadioStation *s = NULL;
if (idx >= 0 && idx < m_stations.count()) {
s = &m_stations.at(idx);
}
editStationName ->setDisabled(!s);
labelStationName ->setDisabled(!s);
editPixmapFile ->setDisabled(!s);
labelPixmapFile ->setDisabled(!s);
editStationShortName ->setDisabled(!s);
labelStationShortName ->setDisabled(!s);
editVolumePreset ->setDisabled(!s);
labelVolumePreset ->setDisabled(!s);
buttonSelectPixmapFile->setDisabled(!s);
buttonDeleteStation ->setDisabled(!s);
buttonStationUp ->setDisabled(!s || idx == 0);
buttonStationDown ->setDisabled(!s || idx == m_stations.count()-1);
if (ignoreChanges) return;
ignoreChanges = true;
editStationName ->setText (s ? s->name() : TQString());
editStationShortName ->setText (s ? s->shortName() : TQString());
editPixmapFile ->setText (s ? s->iconName() : TQString());
editVolumePreset ->setValue (s ? (int)rint(s->initialVolume()*100) : -1);
TQPixmap pixmap(s ? s->iconName() : TQString());
if (!pixmap.isNull()) {
pixmapStation->setPixmap(pixmap);
} else {
pixmapStation->setText("");
}
stackStationEdit->setDisabled(!s);
if (s) {
RadioStationConfig *c = stationEditors.find(s->getClassName());
if (!c) {
c = s->createEditor();
if (c) {
c->reparent(this, TQPoint(0,0), true);
TQObject::connect(c, TQ_SIGNAL(changed(RadioStationConfig*)),
this, TQ_SLOT(slotStationEditorChanged(RadioStationConfig*)));
stationEditors.insert(s->getClassName(), c);
stackStationEdit->addWidget(c);
}
}
if (c) {
c->setStationData(*s);
stackStationEdit->raiseWidget(c);
}
}
ignoreChanges = false;
}
void RadioConfiguration::slotNewStation()
{
slotSetDirty();
const RadioStation *st = &queryCurrentStation();
int n = m_stations.count();
m_stations.all().append(st);
if (m_stations.count() == n) {
st = st->copyNewID();
m_stations.all().append(st);
}
if (m_stations.count() > n) {
listStations->appendStation(*st);
listStations->setCurrentStation (listStations->count()-1);
slotStationSelectionChanged(listStations->count()-1);
listStations->ensureItemVisible(listStations->selectedItem());
}
}
void RadioConfiguration::slotDeleteStation()
{
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
m_stations.all().remove(idx);
listStations->removeStation(idx);
}
}
void RadioConfiguration::slotStationEditorChanged(RadioStationConfig *c)
{
if (!c) return;
if (ignoreChanges) return;
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
RadioStation &st = m_stations.at(idx);
ignoreChanges = true;
bool o = listStations->signalsBlocked();
listStations->blockSignals(true);
c->storeStationData(st);
listStations->setStation(idx, st);
listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotStationNameChanged( const TQString & s)
{
if (ignoreChanges) return;
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
RadioStation &st = m_stations.at(idx);
st.setName(s);
ignoreChanges = true;
bool o = listStations->signalsBlocked();
listStations->blockSignals(true);
listStations->setStation(idx, st);
listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotStationShortNameChanged( const TQString & sn)
{
if (ignoreChanges) return;
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
RadioStation &st = m_stations.at(idx);
st.setShortName(sn);
ignoreChanges = true;
bool o = listStations->signalsBlocked();
listStations->blockSignals(true);
listStations->setStation(idx, st);
listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotSelectPixmap()
{
KURL url = KFileDialog::getImageOpenURL(TQString(), this,
i18n("Image Selection"));
if (!url.isEmpty()) {
if (url.isLocalFile()) {
editPixmapFile->setText(url.path());
} else {
m_logger.logWarning(i18n("ignoring non-local image"));
}
}
}
void RadioConfiguration::slotPixmapChanged( const TQString &s )
{
if (ignoreChanges) return;
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
RadioStation &st = m_stations.at(idx);
st.setIconName(s);
ignoreChanges = true;
pixmapStation->setPixmap(TQPixmap(s));
bool o = listStations->signalsBlocked();
listStations->blockSignals(true);
listStations->setStation(idx, st);
listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotVolumePresetChanged(int v)
{
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count()) {
slotSetDirty();
RadioStation &s = m_stations.at(idx);
s.setInitialVolume(0.01 * (double)v);
}
}
void RadioConfiguration::slotStationUp()
{
int idx = listStations->currentStationIndex();
if (idx > 0 && idx < m_stations.count()) {
slotSetDirty();
RawStationList &sl = m_stations.all();
RadioStation *st = sl.take(idx-1);
sl.insert(idx, st);
delete st;
ignoreChanges = true;
// bool o = listStations->signalsBlocked();
// listStations->blockSignals(true);
listStations->setStation(idx-1, *sl.at(idx-1));
listStations->setStation(idx, *sl.at(idx));
listStations->setCurrentStation(idx-1);
// listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotStationDown()
{
int idx = listStations->currentStationIndex();
if (idx >= 0 && idx < m_stations.count() - 1) {
slotSetDirty();
RawStationList &sl = m_stations.all();
RadioStation *st = sl.take(idx);
sl.insert(idx+1, st);
delete st;
ignoreChanges = true;
// bool o = listStations->signalsBlocked();
// listStations->blockSignals(true);
listStations->setStation(idx, *sl.at(idx));
listStations->setStation(idx+1, *sl.at(idx+1));
listStations->setCurrentStation(idx+1);
// listStations->blockSignals(o);
ignoreChanges = false;
}
}
void RadioConfiguration::slotActivateStation(int idx)
{
if (idx >= 0 && idx < m_stations.count()) {
sendActivateStation(m_stations.at(idx));
sendPowerOn();
}
}
void RadioConfiguration::slotLoadPresets()
{
KFileDialog fd(locate("data", "tderadio/presets/"),
("*.krp|" + i18n("TDERadio Preset Files")).ascii(),
this,
i18n("Preset File Selection").ascii(),
true);
fd.setMode(KFile::File | KFile::ExistingOnly);
fd.setCaption (i18n("Select Preset File"));
if (fd.exec() == TQDialog::Accepted) {
slotSetDirty();
StationList sl;
if (sl.readXML(fd.selectedURL(), m_logger)) {
noticeStationsChanged(sl);
}
}
}
void RadioConfiguration::slotStorePresets()
{
KFileDialog fd("",
("*.krp|" + i18n("TDERadio Preset Files")).ascii(),
this,
i18n("Preset File Selection").ascii(),
true);
fd.setMode(KFile::File);
fd.setCaption (i18n("Store Preset File"));
if (fd.exec() == TQDialog::Accepted) {
editPresetFile->setURL(fd.selectedURL().url());
m_stations.writeXML(fd.selectedURL(), m_logger);
}
}
void RadioConfiguration::slotLastChangeNow()
{
slotSetDirty();
editLastChange->setDateTime(TQDateTime::currentDateTime());
}
static TQString &urlEscapes(TQString &s)
{
s.replace(TQRegExp("%"), "%25");
s.replace(TQRegExp("\t"), "%09");
s.replace(TQRegExp("\n"), "%0A");
s.replace(TQRegExp("\n"), "%0D");
s.replace(TQRegExp(" "), "%20");
s.replace(TQRegExp("\\!"), "%21");
s.replace(TQRegExp("\""), "%22");
s.replace(TQRegExp("#"), "%23");
s.replace(TQRegExp("\\$"), "%24");
s.replace(TQRegExp("\\&"), "%26");
s.replace(TQRegExp("'"), "%27");
s.replace(TQRegExp(","), "%2C");
s.replace(TQRegExp(":"), "%3A");
s.replace(TQRegExp(";"), "%3B");
s.replace(TQRegExp("="), "%3D");
s.replace(TQRegExp("\\?"), "%3F");
return s;
}
void RadioConfiguration::slotSendPresetsByMail( const TQString &url )
{
TQString presets = m_stations.writeXML(m_logger);
urlEscapes(presets);
// documentation says, krun object deletes itself,
// so we do not need to store the pointer
TQString country = m_stations.metaData().country;
TQString city = m_stations.metaData().city;
TQString location = city + "/" + country;
urlEscapes(location);
TQString cmd = url + "?subject=station preset file for " + location + "&body=";
cmd += presets;
new KRun (cmd);
}
void RadioConfiguration::slotSearchStations(int idev)
{
if (idev >= 0 && (unsigned)idev < devices.count()) {
IRadioDevice *dev = devices.at(idev);
StandardScanDialog *x = new StandardScanDialog(NULL);
x->connectI(dev); // connect device
x->connectI(IRadioDevicePoolClient::iConnections.at(0)); // connect radio to get verbous station information
sendActiveDevice(dev);
x->show();
x->start();
if (x->exec() == TQDialog::Accepted) {
slotSetDirty();
m_stations.merge(x->getStations());
noticeStationsChanged(m_stations);
}
delete x;
// logDebug("scan finished");
}
// logDebug("scan finished completely");
}
void RadioConfiguration::slotOK()
{
if (m_dirty) {
StationListMetaData &i = m_stations.metaData();
i.maintainer = editMaintainer->text();
i.lastChange = editLastChange->dateTime();
i.country = editCountry->text();
i.city = editCity->text();
i.media = editMedia->text();
i.comment = editComment->text();
sendStations(m_stations);
sendPresetFile(editPresetFile->url());
m_dirty = false;
}
}
void RadioConfiguration::slotCancel()
{
if (m_dirty) {
noticeStationsChanged(queryStations());
noticePresetFileChanged(queryPresetFile());
m_dirty = false;
}
}
void RadioConfiguration::slotSetDirty()
{
if (!ignoreChanges) {
m_dirty = true;
}
}
#include "radio-configuration.moc"
View Git Blame Copy Permalink