void FITSTab::saveFile()
{
int err_status;
char err_text[FLEN_STATUS];
KUrl backupCurrent = currentURL;
QString currentDir = Options::fitsDir();
if (currentURL.path().contains("/tmp/"))
currentURL.clear();
// If no changes made, return.
if( mDirty == false && !currentURL.isEmpty())
return;
if (currentURL.isEmpty())
{
currentURL = KFileDialog::getSaveUrl( currentDir, "*.fits |Flexible Image Transport System");
// if user presses cancel
if (currentURL.isEmpty())
{
currentURL = backupCurrent;
return;
}
if (currentURL.path().contains('.') == 0)
currentURL.setPath(currentURL.path() + ".fits");
if (QFile::exists(currentURL.path()))
{
int r = KMessageBox::warningContinueCancel(0,
i18n( "A file named \"%1\" already exists. "
"Overwrite it?", currentURL.fileName() ),
i18n( "Overwrite File?" ),
KGuiItem(i18n( "&Overwrite" )) );
if(r==KMessageBox::Cancel) return;
}
}
if ( currentURL.isValid() )
{
if ( (err_status = saveFITS('!' + currentURL.path())) < 0)
{
fits_get_errstatus(err_status, err_text);
// Use KMessageBox or something here
KMessageBox::error(0, i18n("FITS file save error: %1",
QString::fromUtf8(err_text)), i18n("FITS Save"));
return;
}
//statusBar()->changeItem(i18n("File saved."), 3);
emit newStatus(i18n("File saved."), FITS_MESSAGE);
modifyFITSState();
} else
{
QString message = i18n( "Invalid URL: %1", currentURL.url() );
KMessageBox::sorry( 0, message, i18n( "Invalid URL" ) );
}
}
void OnkyoRemoteItem::connect_(bool conn)
{
bool linked_ = getConnected();
if( linked_ != conn ){
if(conn){
onkyo_.reset( new OnkyoClient() );
connect(onkyo_.data(), SIGNAL( newStatus(QString) ), this, SLOT(status_(QString)) );
connect(onkyo_.data(), SIGNAL( error(QString)), this, SLOT(error_(QString)) );
if(addr_.isEmpty())
onkyo_->init();
else {
DeviceInfo d;
d.addr = QHostAddress(addr_);
d.port = port_;
onkyo_->init(d);
}
onkyo_->setConnected(true);
}
else {//make diskonnect
if(! onkyo_.isNull() ){
this->disconnect(onkyo_.data());
onkyo_.reset();
}
}
emit connectChanged();
}
}
void EnobioStatusConsumer::receiveData(const PData &data)
{
StatusData * pStatus = (StatusData *)data.getData();
// Provide the data to whatever slot is connected to that signal
emit newStatus(QDate::currentDate().toString("dd/MM/yyyy") + " " +
QTime::currentTime().toString("hh:mm:ss") + " " +
QString::fromStdString(StatusData::getTypeFromCode(pStatus->getCode())) +
": " + QString::fromStdString(pStatus->getString()));
}
void Project::insertFile(const KURL& nameURL, bool repaint )
{
if (d->excludeRx.exactMatch(nameURL.path()))
return;
KURL url = nameURL;
if ( !d->baseURL.isParentOf(url) )
{
KURLRequesterDlg *urlRequesterDlg = new KURLRequesterDlg( d->baseURL.prettyURL(), d->m_mainWindow, "");
urlRequesterDlg->setCaption(i18n("%1: Copy to Project").arg(nameURL.prettyURL(0, KURL::StripFileProtocol)));
urlRequesterDlg->urlRequester()->setMode( KFile::Directory | KFile::ExistingOnly);
urlRequesterDlg->exec();
KURL destination = urlRequesterDlg->selectedURL();
if (destination.isLocalFile())
{
QDir dir(destination.path());
destination.setPath(dir.canonicalPath());
}
delete urlRequesterDlg;
if ( !destination.isEmpty() )
{
CopyTo *dlg = new CopyTo(d->baseURL);
connect(dlg, SIGNAL(deleteDialog(CopyTo*)), d,
SLOT(slotDeleteCopytoDlg(CopyTo*)));
url = dlg->copy( nameURL, destination );
}
else // Copy canceled, addition aborted
{
return;
}
}
QDomElement el;
while ( d->baseURL.isParentOf(url) )
{
if ( !d->m_projectFiles.contains(url) )
{
el = d->dom.createElement("item");
el.setAttribute("url", QuantaCommon::qUrl( QExtFileInfo::toRelative(url, d->baseURL) ));
d->dom.firstChild().firstChild().appendChild( el );
KURL u = url.upURL();
ProjectURL *parentURL = d->m_projectFiles.find(u);
int uploadStatus = 1;
if (parentURL)
uploadStatus = parentURL->uploadStatus;
d->m_projectFiles.insert( new ProjectURL(url, "", uploadStatus, false, el) );
}
url.setPath(url.directory(false));
}
emit eventHappened("after_project_add", url.url(), QString::null);
setModified();
if ( repaint )
{
emit reloadTree( &(d->m_projectFiles), false, QStringList());
emit newStatus();
}
}
//This is the main modifier function, which recieves a student from main.cpp when user enters a valid ID to modify.
//When it has finished testing for user modifications, it will return the modified student object back to main.cpp.
// The object returned is a clone of the original student object, copied into the original on the users confirmation
student * modifyStudent(student * modifyStudent){
string modifiedName;
string modifiedStatus;
float modifiedGPA;
if(newFirstName(modifiedName))modifyStudent->setFirstName(modifiedName);
if(newLastName(modifiedName))modifyStudent->setLastName(modifiedName);
if(newStatus(modifiedStatus))modifyStudent->setStatus(modifiedStatus);
if(newGPA(modifiedGPA))modifyStudent->setGPA(modifiedGPA);
return modifyStudent;
}
bool FITSTab::loadFITS(const KUrl *imageURL, FITSMode mode, FITSScale filter)
{
if (image == NULL)
{
image = new FITSView(this, mode);
image->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QVBoxLayout *vlayout = new QVBoxLayout();
vlayout->addWidget(image);
setLayout(vlayout);
connect(image, SIGNAL(newStatus(QString,FITSBar)), this, SIGNAL(newStatus(QString,FITSBar)));
}
currentURL = *imageURL;
bool imageLoad = image->loadFITS(imageURL->url());
if (imageLoad)
{
if (histogram == NULL)
histogram = new FITSHistogram(this);
else
histogram->updateHistogram();
FITSImage *image_data = image->getImageData();
image_data->setHistogram(histogram);
image_data->applyFilter(filter);
if (filter != FITS_NONE)
image->rescale(ZOOM_KEEP_LEVEL);
if (viewer->isStarsMarked())
image->toggleStars(true);
image->updateFrame();
}
return imageLoad;
}
void KateBtBrowserPlugin::startIndexer()
{
if (indexer.isRunning()) {
indexer.cancel();
indexer.wait();
}
KConfigGroup cg(KSharedConfig::openConfig(), "backtracebrowser");
indexer.setSearchPaths(cg.readEntry("search-folders", QStringList()));
indexer.setFilter(cg.readEntry("file-extensions", fileExtensions));
indexer.start();
emit newStatus(i18n("Indexing files..."));
}
void Server::queryFinished()
{
ServerTask::Query* query(qobject_cast<ServerTask::Query*>(sender()));
if (!query) return;
Process* process(query->process());
Process::Status oldStatus(process->status());
Process::Status newStatus(query->newStatus());
// Check for any error and bail cos, really, we don't know what's going on
QString msg(query->errorMessage());
if (!msg.isEmpty()) {
process->setComment(msg);
process->setStatus(Process::Unknown);
#ifndef Q_WS_WIN32
query->deleteLater();
#endif
return;
}
if (oldStatus == Process::Queued ||
oldStatus == Process::Running ||
oldStatus == Process::Suspended ||
oldStatus == Process::Unknown) {
if (newStatus == Process::Unknown) {
ServerTask::Base* task(cleanUp(process));
if (task) {
connect(task, SIGNAL(finished()), this, SLOT(cleanUpFinished()));
task->start();
}
removeFromWatchList(process);
#ifndef Q_WS_WIN32
query->deleteLater();
#endif
return;
}else if (newStatus == Process::Queued ||
newStatus == Process::Running ||
newStatus == Process::Suspended) {
process->setStatus(newStatus);
}else {
process->setStatus(newStatus);
removeFromWatchList(process);
QLOG_WARN() << "Inactive process found in Server::queryFinished";
}
}else {
removeFromWatchList(process);
}
#ifndef Q_WS_WIN32
query->deleteLater();
#endif
}
StatusNotifierButton::StatusNotifierButton(QString service, QString objectPath, ILXQtPanelPlugin* plugin, QWidget *parent)
: QToolButton(parent),
mMenu(NULL),
mStatus(Passive),
mValid(true),
mFallbackIcon(QIcon::fromTheme("application-x-executable")),
mPlugin(plugin)
{
interface = new org::kde::StatusNotifierItem(service, objectPath, QDBusConnection::sessionBus(), this);
QString menuPath = interface->menu().path();
if (!menuPath.isEmpty())
{
mMenu = (new DBusMenuImporter(service, interface->menu().path(), this))->menu();
dynamic_cast<QObject &>(*mMenu).setParent(this);
mMenu->setObjectName(QStringLiteral("StatusNotifierMenu"));
}
// HACK: sni-qt creates some invalid items (like one for konversarion 1.5)
if (interface->title().isEmpty() && interface->id().isEmpty())
mValid = false;
if (mValid)
{
newToolTip();
refetchIcon(Active);
refetchIcon(Passive);
refetchIcon(NeedsAttention);
newStatus(interface->status());
resetIcon();
connect(interface, SIGNAL(NewIcon()), this, SLOT(newIcon()));
connect(interface, SIGNAL(NewOverlayIcon()), this, SLOT(newOverlayIcon()));
connect(interface, SIGNAL(NewAttentionIcon()), this, SLOT(newAttentionIcon()));
connect(interface, SIGNAL(NewToolTip()), this, SLOT(newToolTip()));
connect(interface, SIGNAL(NewStatus(QString)), this, SLOT(newStatus(QString)));
}
}
KateBtBrowserPluginView::KateBtBrowserPluginView(KateBtBrowserPlugin *plugin, KTextEditor::MainWindow *mainWindow)
: QObject(mainWindow), m_plugin(plugin)
{
// init console
QWidget *toolview = mainWindow->createToolView(plugin,
QStringLiteral("kate_private_plugin_katebacktracebrowserplugin"),
KTextEditor::MainWindow::Bottom,
QIcon::fromTheme(QStringLiteral("kbugbuster")),
i18n("Backtrace Browser"));
m_widget = new KateBtBrowserWidget(mainWindow, toolview);
connect(plugin, SIGNAL(newStatus(QString)),
m_widget, SLOT(setStatus(QString)));
}
void QmlAdapter::createDebuggerClients()
{
Internal::QScriptDebuggerClient *client1 = new Internal::QScriptDebuggerClient(d->m_conn);
connect(client1, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
this, SLOT(clientStatusChanged(QDeclarativeDebugClient::Status)));
connect(client1, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
this, SLOT(debugClientStatusChanged(QDeclarativeDebugClient::Status)));
Internal::QmlV8DebuggerClient *client2 = new Internal::QmlV8DebuggerClient(d->m_conn);
connect(client2, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
this, SLOT(clientStatusChanged(QDeclarativeDebugClient::Status)));
connect(client2, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
this, SLOT(debugClientStatusChanged(QDeclarativeDebugClient::Status)));
d->debugClients.insert(client1->name(),client1);
d->debugClients.insert(client2->name(),client2);
client1->setEngine((Internal::QmlEngine*)(d->m_engine.data()));
client2->setEngine((Internal::QmlEngine*)(d->m_engine.data()));
//engine->startSuccessful(); // FIXME: AAA: port to new debugger states
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
g = new sub3dtoolgui;
connect(g, SIGNAL(closeProgram()), this, SLOT(close()));
connect(g, SIGNAL(newStatus(QString)), ui->statusBar, SLOT(showMessage(QString)));
g->init();
this->setCentralWidget(g);
this->layout()->setSizeConstraint(QLayout::SetFixedSize);
}
AppletInterface::AppletInterface(AbstractJsAppletScript *parent)
: QObject(parent),
m_appletScriptEngine(parent),
m_actionSignals(0)
{
connect(this, SIGNAL(releaseVisualFocus()), applet(), SIGNAL(releaseVisualFocus()));
connect(this, SIGNAL(configNeedsSaving()), applet(), SIGNAL(configNeedsSaving()));
connect(applet(), SIGNAL(immutabilityChanged(Plasma::ImmutabilityType)), this, SIGNAL(immutableChanged()));
connect(applet(), SIGNAL(newStatus(Plasma::ItemStatus)), this, SIGNAL(statusChanged()));
connect(m_appletScriptEngine, SIGNAL(formFactorChanged()),
this, SIGNAL(formFactorChanged()));
connect(m_appletScriptEngine, SIGNAL(locationChanged()),
this, SIGNAL(locationChanged()));
connect(m_appletScriptEngine, SIGNAL(contextChanged()),
this, SIGNAL(contextChanged()));
}
//-----------------------------------------------------------------------
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QTextCodec *codec = QTextCodec::codecForName("UTF-8");
QTextCodec::setCodecForTr(codec);
QTextCodec::setCodecForCStrings(codec);
Options opts;
opts.parse_args(argc, argv);
CliPrinter prn;
OnkyoClient cli;
QObject::connect(&cli, SIGNAL( error(QString) ), &prn, SLOT( cerr(QString)) );
QObject::connect(&cli, SIGNAL( newStatus(QString) ), &prn, SLOT( cout(QString)) );
if( !opts.host ){
if( ! cli.init() )
opts.display_usage_and_exit();
else
prn.cout( cli.getDeviceInfo().toString() );
}
else {
DeviceInfo d;
d.addr = QHostAddress(opts.host);
d.port = opts.port;
cli.init(d);
}
if( opts.tmdelay > 0)
QTimer::singleShot( opts.tmdelay, &a, SLOT( quit() ) );
cli.setConnected(true);
if(opts.cmd)
cli.request(opts.cmd);
if( opts.numInputCmds ){
for (int i=0; i< opts.numInputCmds; ++i ){
cli.request( opts.inputCmds[i] );
qDebug()<< opts.inputCmds[i]<< " sended.";
}
}
return a.exec();
}
//rename the elements in the project dom tree
void Project::slotRenamed(const KURL& oldURL, const KURL& newURL)
{
if ( oldURL == newURL) // just in case
return;
// remove the target if already there
// TODO: check if this is correct because it removes a folder but not the content?
d->m_projectFiles.removeFromListAndXML(newURL);
emit statusMsg(i18n("Renaming files..."));
progressBar->setTotalSteps(d->m_projectFiles.count());
progressBar->setValue(0);
progressBar->setTextEnabled(true);
QDomElement el;
bool isFolder = oldURL.fileName(false).isEmpty();
ProjectList::Iterator it( d->m_projectFiles );
for ( ; it.current(); ++it)
{
ProjectURL * curUrl = it.current();
if ( oldURL == *curUrl || (isFolder && oldURL.isParentOf(*curUrl)) )
{
curUrl->setPath( curUrl->path().replace(oldURL.path(), newURL.path()) );
el = curUrl->domElement;
el.setAttribute("url", d->m_projectFiles.toRelative(*curUrl).path());
// el.setAttribute("upload_time", "");
d->m_modified = true;
if (! isFolder)
break;
}
progressBar->advance(1);
}
progressBar->setTotalSteps(1);
progressBar->setValue(0);
progressBar->setTextEnabled(false);
emit statusMsg(QString::null);
if (d->m_modified)
setModified(); // there happens more than setting the flag !
emit reloadTree(&(d->m_projectFiles), false, QStringList());
emit newStatus();
}
Cooller_ModBusController::Cooller_ModBusController(CoolerStateWidget *view, ModBusDialog *config) :
m_view(view),
m_configDialog(config),
m_recheckTimer(new QTimer(this)),
m_available(false),
m_comunicationSpeedIndex(6), //9600
m_currentDeviceID(1),
m_connector(this),
m_externalManager(this),
m_modbus(this)
{
connect(m_recheckTimer, SIGNAL(timeout()), this, SLOT(updateState()));
m_recheckTimer->setInterval(500);
m_recheckTimer->start();
config->setExternalCommunicator(&m_connector);
connect(m_configDialog, SIGNAL(speedChanged(int)), this, SLOT(newSpeed(int)));
connect(m_configDialog, SIGNAL(portChanged(int)), this, SLOT(newPort(int)));
connect(m_configDialog, SIGNAL(deviceIDChanged(int)), this, SLOT(newDevice(int)));
connect(&m_connector, SIGNAL(connectionEstablished()), config, SLOT(connectionEstablished()));
connect(&m_connector, SIGNAL(connectionEstablished()), this, SLOT(sendConfiguration()));
connect(&m_connector, SIGNAL(connectionBroken()), config, SLOT(connectionBroken()));
connect(&m_connector, SIGNAL(connectionErrorOccured(QString)), config, SLOT(connectionErrorOccured(QString)));
connect(&m_externalManager, SIGNAL(stateChanged()), this, SLOT(externalStateChanged()));
connect(&m_externalManager, SIGNAL(listChanged()), this, SLOT(externalListChanged()));
connect(&m_modbus, SIGNAL(deviceListUpdated(void)), this, SLOT(deviceObserverWaked()));
QString configsPath = Configurator::getConfigFilesPath();
QDirIterator iter(configsPath, QStringList() << "*.xml", QDir::Files | QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags);
int configsRed = 0;
while (iter.hasNext())
{
iter.next();
QString xmlFilePath = iter.filePath();
if (readXMLConfig(xmlFilePath))
configsRed++;
}
if (0 == configsRed )
{
emit newStatus(tr("No config files were found"));
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
// The consumers signals every time they receive new data and status so
// their signals are directly connected to the TextEdit in the GUI
QObject::connect(&_enobioDataConsumer, SIGNAL(newData(QString)),
ui->dataTextEdit, SLOT(append(QString)));
QObject::connect(&_enobioStatusConsumer, SIGNAL(newStatus(QString)),
ui->statusTextEdit, SLOT(append(QString)));
// The consumers are registereds into the Enobio processor in order to
// receive both data and status
_enobio.registerConsumer(Enobio3G::ENOBIO_DATA, _enobioDataConsumer);
_enobio.registerConsumer(Enobio3G::STATUS, _enobioStatusConsumer);
//_enobio.setDemoMode(true, "demosignals.txt");
}
StatusNotifierButton::StatusNotifierButton(QString service, QString objectPath, ILXQtPanelPlugin* plugin, QWidget *parent)
: QToolButton(parent),
mMenu(nullptr),
mStatus(Passive),
mFallbackIcon(QIcon::fromTheme("application-x-executable")),
mPlugin(plugin)
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setAutoRaise(true);
interface = new SniAsync(service, objectPath, QDBusConnection::sessionBus(), this);
connect(interface, &SniAsync::NewIcon, this, &StatusNotifierButton::newIcon);
connect(interface, &SniAsync::NewOverlayIcon, this, &StatusNotifierButton::newOverlayIcon);
connect(interface, &SniAsync::NewAttentionIcon, this, &StatusNotifierButton::newAttentionIcon);
connect(interface, &SniAsync::NewToolTip, this, &StatusNotifierButton::newToolTip);
connect(interface, &SniAsync::NewStatus, this, &StatusNotifierButton::newStatus);
interface->propertyGetAsync(QLatin1String("Menu"), [this] (QDBusObjectPath path) {
if (!path.path().isEmpty())
{
mMenu = (new MenuImporter{interface->service(), path.path(), this})->menu();
mMenu->setObjectName(QLatin1String("StatusNotifierMenu"));
}
});
interface->propertyGetAsync(QLatin1String("Status"), [this] (QString status) {
newStatus(status);
});
interface->propertyGetAsync(QLatin1String("IconThemePath"), [this] (QString value) {
//do the logic of icons after we've got the theme path
refetchIcon(Active, value);
refetchIcon(Passive, value);
refetchIcon(NeedsAttention, value);
});
newToolTip();
}
void Server::queryFinished()
{
ServerTask::Query* task = qobject_cast<ServerTask::Query*>(sender());
if (!task) return;
Process* process(task->process());
Process::Status oldStatus(process->status());
Process::Status newStatus(task->newStatus());
task->deleteLater();
if (oldStatus == Process::Queued ||
oldStatus == Process::Running ||
oldStatus == Process::Suspended ||
oldStatus == Process::Unknown) {
if (newStatus == Process::Unknown) {
ServerTask::Base* task(cleanUp(process));
if (task) {
connect(task, SIGNAL(finished()), this, SLOT(cleanUpFinished()));
task->start();
}
removeFromWatchList(process);
return;
} else if (newStatus == Process::Queued ||
newStatus == Process::Running ||
newStatus == Process::Suspended) {
process->setStatus(newStatus);
} else {
process->setStatus(newStatus);
removeFromWatchList(process);
QLOG_WARN() << "Inactive process found in Server::queryFinished";
}
} else {
removeFromWatchList(process);
}
}
void Mount::updateTelescopeCoords()
{
double ra, dec;
if (currentTelescope && currentTelescope->getEqCoords(&ra, &dec))
{
telescopeCoord.setRA(ra);
telescopeCoord.setDec(dec);
telescopeCoord.EquatorialToHorizontal(KStarsData::Instance()->lst(), KStarsData::Instance()->geo()->lat());
raOUT->setText(telescopeCoord.ra().toHMSString());
decOUT->setText(telescopeCoord.dec().toDMSString());
azOUT->setText(telescopeCoord.az().toDMSString());
altOUT->setText(telescopeCoord.alt().toDMSString());
dms lst = KStarsData::Instance()->geo()->GSTtoLST( KStarsData::Instance()->clock()->utc().gst() );
dms ha( lst.Degrees() - telescopeCoord.ra().Degrees() );
QChar sgn('+');
if ( ha.Hours() > 12.0 ) {
ha.setH( 24.0 - ha.Hours() );
sgn = '-';
}
haOUT->setText( QString("%1%2").arg(sgn).arg( ha.toHMSString() ) );
lstOUT->setText(lst.toHMSString());
double currentAlt = telescopeCoord.altRefracted().Degrees();
if (minAltLimit->isEnabled()
&& ( currentAlt < minAltLimit->value() || currentAlt > maxAltLimit->value()))
{
if (currentAlt < minAltLimit->value())
{
// Only stop if current altitude is less than last altitude indicate worse situation
if (currentAlt < lastAlt && (abortDispatch == -1 || (currentTelescope->isInMotion()/* && ++abortDispatch > ABORT_DISPATCH_LIMIT*/)))
{
appendLogText(i18n("Telescope altitude is below minimum altitude limit of %1. Aborting motion...", QString::number(minAltLimit->value(), 'g', 3)));
currentTelescope->Abort();
//KNotification::event( QLatin1String( "OperationFailed" ));
KNotification::beep();
abortDispatch++;
}
}
else
{
// Only stop if current altitude is higher than last altitude indicate worse situation
if (currentAlt > lastAlt && (abortDispatch == -1 || (currentTelescope->isInMotion()/* && ++abortDispatch > ABORT_DISPATCH_LIMIT*/)))
{
appendLogText(i18n("Telescope altitude is above maximum altitude limit of %1. Aborting motion...", QString::number(maxAltLimit->value(), 'g', 3)));
currentTelescope->Abort();
//KNotification::event( QLatin1String( "OperationFailed" ));
KNotification::beep();
abortDispatch++;
}
}
}
else
abortDispatch = -1;
lastAlt = currentAlt;
newCoords(raOUT->text(), decOUT->text(), azOUT->text(), altOUT->text());
newStatus(currentTelescope->getStatus());
if (currentTelescope->isConnected())
QTimer::singleShot(UPDATE_DELAY, this, SLOT(updateTelescopeCoords()));
}
}
void CEXIChannel::Write32(const u32 _iValue, const u32 _iRegister)
{
DEBUG_LOG(EXPANSIONINTERFACE, "(w32) 0x%08x channel: %i register: %s",
_iValue, m_ChannelId, Debug_GetRegisterName(_iRegister));
switch (_iRegister)
{
case EXI_STATUS:
{
UEXI_STATUS newStatus(_iValue);
m_Status.EXIINTMASK = newStatus.EXIINTMASK;
if (newStatus.EXIINT)
m_Status.EXIINT = 0;
m_Status.TCINTMASK = newStatus.TCINTMASK;
if (newStatus.TCINT)
m_Status.TCINT = 0;
m_Status.CLK = newStatus.CLK;
if (m_ChannelId == 0 || m_ChannelId == 1)
{
m_Status.EXTINTMASK = newStatus.EXTINTMASK;
if (newStatus.EXTINT)
m_Status.EXTINT = 0;
}
if (m_ChannelId == 0)
m_Status.ROMDIS = newStatus.ROMDIS;
IEXIDevice* pDevice = GetDevice(m_Status.CHIP_SELECT ^ newStatus.CHIP_SELECT);
m_Status.CHIP_SELECT = newStatus.CHIP_SELECT;
if (pDevice != NULL)
pDevice->SetCS(m_Status.CHIP_SELECT);
CoreTiming::ScheduleEvent_Threadsafe_Immediate(updateInterrupts, 0);
}
break;
case EXI_DMAADDR:
INFO_LOG(EXPANSIONINTERFACE, "Wrote DMAAddr, channel %i", m_ChannelId);
m_DMAMemoryAddress = _iValue;
break;
case EXI_DMALENGTH:
INFO_LOG(EXPANSIONINTERFACE, "Wrote DMALength, channel %i", m_ChannelId);
m_DMALength = _iValue;
break;
case EXI_DMACONTROL:
INFO_LOG(EXPANSIONINTERFACE, "Wrote DMAControl, channel %i", m_ChannelId);
m_Control.Hex = _iValue;
if (m_Control.TSTART)
{
IEXIDevice* pDevice = GetDevice(m_Status.CHIP_SELECT);
if (pDevice == NULL)
return;
if (m_Control.DMA == 0)
{
// immediate data
switch (m_Control.RW)
{
case EXI_READ: m_ImmData = pDevice->ImmRead(m_Control.TLEN + 1); break;
case EXI_WRITE: pDevice->ImmWrite(m_ImmData, m_Control.TLEN + 1); break;
case EXI_READWRITE: pDevice->ImmReadWrite(m_ImmData, m_Control.TLEN + 1); break;
default: _dbg_assert_msg_(EXPANSIONINTERFACE,0,"EXI Imm: Unknown transfer type %i", m_Control.RW);
}
m_Control.TSTART = 0;
}
else
{
// DMA
switch (m_Control.RW)
{
case EXI_READ: pDevice->DMARead (m_DMAMemoryAddress, m_DMALength); break;
case EXI_WRITE: pDevice->DMAWrite(m_DMAMemoryAddress, m_DMALength); break;
default: _dbg_assert_msg_(EXPANSIONINTERFACE,0,"EXI DMA: Unknown transfer type %i", m_Control.RW);
}
m_Control.TSTART = 0;
}
if(!m_Control.TSTART) // completed !
{
m_Status.TCINT = 1;
CoreTiming::ScheduleEvent_Threadsafe_Immediate(updateInterrupts, 0);
}
}
break;
case EXI_IMMDATA:
INFO_LOG(EXPANSIONINTERFACE, "Wrote IMMData, channel %i", m_ChannelId);
m_ImmData = _iValue;
break;
}
}
void FITSTab::tabPositionUpdated()
{
undoStack->setActive(true);
emit newStatus(QString("%1%").arg(image->getCurrentZoom()), FITS_ZOOM);
emit newStatus(QString("%1x%2").arg(image->getImageData()->getWidth()).arg(image->getImageData()->getHeight()), FITS_RESOLUTION);
}
void Project::slotRemove(const KURL& urlToRemove)
{
emit statusMsg(i18n("Removing files..."));
progressBar->setTotalSteps(d->m_projectFiles.count());
progressBar->setValue(0);
progressBar->setTextEnabled(true);
KURL url;
bool isFolder = d->m_projectFiles.isFolder(urlToRemove);
ProjectList projectFiles = d->m_projectFiles;
ProjectList::Iterator it(projectFiles);
for ( ; it.current(); ++it)
{
url = *(it.current());
if (urlToRemove == url || (isFolder && urlToRemove.isParentOf(url)) )
{
d->m_projectFiles.removeFromListAndXML(url);
d->m_modified = true;
emit eventHappened("after_project_remove", url.url(), QString::null);
if (!isFolder)
break;
}
progressBar->advance(1);
}
progressBar->setTotalSteps(1);
progressBar->setValue(0);
progressBar->setTextEnabled(false);
emit statusMsg(QString::null);
if (d->m_modified)
setModified(); // there happens more than setting the flag !
emit reloadTree( &(d->m_projectFiles), false, QStringList() );
emit newStatus();
QString urlPath = QExtFileInfo::toRelative(urlToRemove, d->baseURL).path();
QString nice = urlPath;
nice = KStringHandler::lsqueeze(nice, 60);
if (KMessageBox::warningContinueCancel(d->m_mainWindow, i18n("<qt>Do you want to remove <br><b>%1</b><br> from the server(s) as well?</qt>").arg(nice), i18n("Remove From Server"), KStdGuiItem::remove(), "RemoveFromServer") == KMessageBox::Continue )
{
QDomNode profilesNode = d->m_sessionDom.firstChild().firstChild().namedItem("uploadprofiles");
QDomNodeList profileList = profilesNode.toElement().elementsByTagName("profile");
QDomElement e;
QString s;
for (uint i = 0; i < profileList.count(); i++)
{
e = profileList.item(i).toElement();
QString path = e.attribute("remote_path","");
if (!path.startsWith("/"))
path.prepend("/");
KURL baseUrl;
baseUrl.setProtocol(e.attribute("remote_protocol","ftp"));
baseUrl.setPort(e.attribute("remote_port","").toInt());
baseUrl.setHost(e.attribute("remote_host",""));
baseUrl.setPath(path);
baseUrl.setUser(e.attribute("user",""));
QString passwd = password(e.attribute("remote_protocol") + "://" + e.attribute("user") + "@" + e.attribute("remote_host"));
baseUrl.setPass(passwd);
baseUrl.addPath(urlPath);
KIO::NetAccess::del(baseUrl, d->m_mainWindow);
}
}
}
void QDebugMessageClient::statusChanged(ClientStatus status)
{
emit newStatus(status);
}
void
RefFreeFrame::updateUIState(QCAR::ImageTargetBuilder * targetBuilder,
QCAR::ImageTargetBuilder::FRAME_QUALITY frameQuality)
{
// ** Elapsed time
unsigned int elapsedTimeMS = getTimeMS() - lastFrameTime;
lastFrameTime += elapsedTimeMS;
// This is a time-dependent value used for transitions in the range [0, 1]
// over the period of half of a second.
float transitionHalfSecond = elapsedTimeMS * 0.002f;
STATUS newStatus(curStatus);
switch (curStatus)
{
case STATUS_IDLE:
if (frameQuality != QCAR::ImageTargetBuilder::FRAME_QUALITY_NONE)
newStatus = STATUS_SCANNING;
break;
case STATUS_SCANNING:
switch (frameQuality)
{
// bad target quality, render the frame white until a match is made, then go to green
case QCAR::ImageTargetBuilder::FRAME_QUALITY_LOW:
colorFrame[0] = 1.0f;
colorFrame[1] = 1.0f;
colorFrame[2] = 1.0f;
break;
// good target, switch to green over half a second
case QCAR::ImageTargetBuilder::FRAME_QUALITY_HIGH:
case QCAR::ImageTargetBuilder::FRAME_QUALITY_MEDIUM:
transition(colorFrame[0], -transitionHalfSecond);
transition(colorFrame[1], transitionHalfSecond);
transition(colorFrame[2], -transitionHalfSecond);
break;
}
break;
case STATUS_CREATING:
{
// check for new result
// if found, set to success, success time and:
QCAR::TrackableSource* newTrackableSource =
targetBuilder->getTrackableSource();
if (newTrackableSource != NULL)
{
newStatus = STATUS_SUCCESS;
lastSuccessTime = lastFrameTime;
trackableSource = newTrackableSource;
targetBuilder->stopScan();
RefFreeFrameNative::targetCreatedCallback();
}
}
default:
break;
}
curStatus = newStatus;
}
void CEXIChannel::RegisterMMIO(MMIO::Mapping* mmio, u32 base)
{
// Warning: the base is not aligned on a page boundary here. We can't use |
// to select a register address, instead we need to use +.
mmio->Register(base + EXI_STATUS, MMIO::ComplexRead<u32>([this](u32) {
// check if external device is present
// pretty sure it is memcard only, not entirely sure
if (m_ChannelId == 2)
{
m_Status.EXT = 0;
}
else
{
m_Status.EXT = GetDevice(1)->IsPresent() ? 1 : 0;
}
return m_Status.Hex;
}),
MMIO::ComplexWrite<u32>([this](u32, u32 val) {
UEXI_STATUS newStatus(val);
m_Status.EXIINTMASK = newStatus.EXIINTMASK;
if (newStatus.EXIINT)
m_Status.EXIINT = 0;
m_Status.TCINTMASK = newStatus.TCINTMASK;
if (newStatus.TCINT)
m_Status.TCINT = 0;
m_Status.CLK = newStatus.CLK;
if (m_ChannelId == 0 || m_ChannelId == 1)
{
m_Status.EXTINTMASK = newStatus.EXTINTMASK;
if (newStatus.EXTINT)
m_Status.EXTINT = 0;
}
if (m_ChannelId == 0)
m_Status.ROMDIS = newStatus.ROMDIS;
IEXIDevice* pDevice = GetDevice(m_Status.CHIP_SELECT ^ newStatus.CHIP_SELECT);
m_Status.CHIP_SELECT = newStatus.CHIP_SELECT;
if (pDevice != nullptr)
pDevice->SetCS(m_Status.CHIP_SELECT);
ExpansionInterface::UpdateInterrupts();
}));
mmio->Register(base + EXI_DMAADDR, MMIO::DirectRead<u32>(&m_DMAMemoryAddress),
MMIO::DirectWrite<u32>(&m_DMAMemoryAddress));
mmio->Register(base + EXI_DMALENGTH, MMIO::DirectRead<u32>(&m_DMALength),
MMIO::DirectWrite<u32>(&m_DMALength));
mmio->Register(base + EXI_DMACONTROL, MMIO::DirectRead<u32>(&m_Control.Hex),
MMIO::ComplexWrite<u32>([this](u32, u32 val) {
m_Control.Hex = val;
if (m_Control.TSTART)
{
IEXIDevice* pDevice = GetDevice(m_Status.CHIP_SELECT);
if (pDevice == nullptr)
return;
if (m_Control.DMA == 0)
{
// immediate data
switch (m_Control.RW)
{
case EXI_READ:
m_ImmData = pDevice->ImmRead(m_Control.TLEN + 1);
break;
case EXI_WRITE:
pDevice->ImmWrite(m_ImmData, m_Control.TLEN + 1);
break;
case EXI_READWRITE:
pDevice->ImmReadWrite(m_ImmData, m_Control.TLEN + 1);
break;
default:
_dbg_assert_msg_(EXPANSIONINTERFACE, 0,
"EXI Imm: Unknown transfer type %i", m_Control.RW);
}
}
else
{
// DMA
switch (m_Control.RW)
{
case EXI_READ:
pDevice->DMARead(m_DMAMemoryAddress, m_DMALength);
break;
case EXI_WRITE:
pDevice->DMAWrite(m_DMAMemoryAddress, m_DMALength);
break;
default:
_dbg_assert_msg_(EXPANSIONINTERFACE, 0,
"EXI DMA: Unknown transfer type %i", m_Control.RW);
}
}
m_Control.TSTART = 0;
// Check if device needs specific timing, otherwise just complete transfer
// immediately
if (!pDevice->UseDelayedTransferCompletion())
SendTransferComplete();
}
}));
mmio->Register(base + EXI_IMMDATA, MMIO::DirectRead<u32>(&m_ImmData),
MMIO::DirectWrite<u32>(&m_ImmData));
}
void BaseToolsClient::statusChanged(ClientStatus status)
{
emit newStatus(status);
}
