// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DevHelper::setupGui()
{
// Allow internal widgets to update the status bar
connect(filterMaker, SIGNAL(updateStatusBar(QString)), this, SLOT(updateStatusMessage(QString)));
connect(pluginMaker, SIGNAL(updateStatusBar(QString)), this, SLOT(updateStatusMessage(QString)));
//Set window to open at the center of the screen
QDesktopWidget* desktop = QApplication::desktop();
int screenWidth, width;
int screenHeight, height;
int x, y;
QSize windowSize;
screenWidth = desktop->width(); // get width of screen
screenHeight = desktop->height(); // get height of screen
windowSize = size(); // size of application window
width = windowSize.width();
height = windowSize.height();
x = (screenWidth - width) / 2;
y = (screenHeight - height) / 2;
y -= 50;
// move window to desired coordinates
move(x, y);
}
AppController::AppController() :
lastTick_(0), frameCounter_(0), frameRate_(0) {
model_ = new AppModel();
gui_ = new MainWindow(model_, this);
// register data update functions to model
boost::function<void()> data_cb = boost::bind(&AppController::dataUpdated,
this);
update_con_ = model_->registerCallback(data_cb);
// register pointpick callback of model to gui
boost::function<void(const pcl::visualization::PointPickingEvent &)> pointpick_cb =
boost::bind(&AppModel::pickPoint, model_, _1);
gui_->registerPointPickCallback(pointpick_cb);
// connect signal / slots to gui
connect(this, SIGNAL(newCloud()), gui_, SLOT(updatePointCloud()));
connect(this, SIGNAL(newSmallCloud(void)), gui_,
SLOT(updateSmallPointCloud(void)));
qRegisterMetaType<QImage>("QImage");
connect(this, SIGNAL(newRgbImage(QImage)), gui_,
SLOT(updateRgbImage(QImage)));
qRegisterMetaType<QString>("QString");
connect(this, SIGNAL(newStatusMessage(QString)), gui_,
SLOT(updateStatusMessage(QString)));
gui_->show();
}
bool WelcomeDialog::updateScheduledList()
{
{
// clear pending flag early in case something happens while
// we're updating
QMutexLocker lock(&m_SchedUpdateMuxtex);
setPendingSchedUpdate(false);
}
m_scheduledList.clear();
m_screenScheduledNo = 0;
if (!gCoreContext->IsConnectedToMaster())
{
updateStatusMessage();
return false;
}
GetNextRecordingList(m_nextRecordingStart, &m_hasConflicts,
&m_scheduledList);
updateStatus();
updateScreen();
return true;
}
void WelcomeDialog::runEPGGrabber(void)
{
runMythFillDatabase();
sleep(1);
updateStatusMessage();
updateScreen();
}
FemtecTester::FemtecTester(SysLogParser *logParser, QObject *parent) :
QObject(parent),
m_serialPort(new QextSerialPort()),
m_logParser(logParser),
m_currentProcedureFSState(Intermediate),
m_targetProcedureFSState(PedalUp),
m_pauseState(NoPause),
m_pauseTimer(new QTimer(this)),
m_statusMessageTimer(new QTimer(this)),
m_fakeTrmPause(false),
m_enabled(false),
m_treatmentDelay(0, 30),
m_pauseDelay(0, 5),
m_pauseLength(1, 30),
m_intermediateLength(0.1, 0.5),
m_statusMessageFormat("%1"),
m_statusMessageCountdown(0)
{
connect(m_pauseTimer, SIGNAL(timeout()), this, SLOT(pauseTimerElapsed()));
connect(m_statusMessageTimer, SIGNAL(timeout()), this, SLOT(updateStatusMessage()));
qsrand(QDateTime::currentDateTime().toTime_t());
loadSettings();
connect(m_logParser, SIGNAL(treatmentStarted()), this, SLOT(pressProcedureFootswitchDelayed()));
connect(m_logParser, SIGNAL(treatmentFinished()), this, SLOT(releaseProcedureFootswitch()));
connect(m_logParser, SIGNAL(treatmentAborted()), this, SLOT(releaseProcedureFootswitch()));
connect(m_logParser, SIGNAL(calStopped(int)), this, SLOT(releaseProcedureFootswitch()));
connect(m_logParser, SIGNAL(executingTreatment()), this, SLOT(pauseTreatment()));
// power check
connect(m_logParser, SIGNAL(powerCheckStarted()), this, SLOT(pressProcedureFootswitch()));
//connect(m_logParser, SIGNAL(procShutterOpened()), this, SLOT(onProcShutterOpen()));
}
void WelcomeDialog::unlockShutdown(void)
{
QString mythshutdown_exe = m_installDir + "/bin/mythshutdown --unlock";
myth_system(mythshutdown_exe);
updateStatusMessage();
updateScreen();
}
void
FlagStatus::sticky_clear(void)
{
for (size_t i = 0; i < item_.size(); ++i) {
item_[i].sticky_decrease();
}
updateStatusMessage();
}
void FlagStatus::negative_lock_clear(void) {
for (size_t i = 0; i < item_.size(); ++i) {
if (item_[i].negative_lock_count_) {
item_[i].negative_lock_decrease();
}
}
updateStatusMessage();
}
void WelcomeDialog::unlockShutdown(void)
{
QString command = m_installDir + "/bin/mythshutdown --unlock";
command += logPropagateArgs;
myth_system(command);
updateStatusMessage();
updateScreen();
}
void FlagStatus::updateStatusMessage(void) {
int indexes[] = {
BRIDGE_USERCLIENT_STATUS_MESSAGE_MODIFIER_LOCK,
BRIDGE_USERCLIENT_STATUS_MESSAGE_MODIFIER_CAPS_LOCK,
BRIDGE_USERCLIENT_STATUS_MESSAGE_MODIFIER_STICKY,
};
for (size_t i = 0; i < sizeof(indexes) / sizeof(indexes[0]); ++i) {
int idx = indexes[i];
static char previousMessage[BRIDGE_USERCLIENT_STATUS_MESSAGE_MAXLEN];
strlcat(previousMessage, CommonData::get_statusmessage(idx), sizeof(previousMessage));
updateStatusMessage(idx);
if (strcmp(CommonData::get_statusmessage(idx), previousMessage) != 0) {
CommonData::send_notification_statusmessage(idx);
}
}
}
int Board::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: pauseChecked((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 1: pauseAvailable((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 2: finished((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4]))); break;
case 3: newGame(); break;
case 4: loadGame(); break;
case 5: saveGame(); break;
case 6: pauseGame((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 7: loadSettings(); break;
case 8: focusChanged(); break;
case 9: updateStatusMessage(); break;
case 10: move(); break;
default: ;
}
_id -= 11;
}
return _id;
}
void FlagStatus::sticky_toggle(Flags flags) { FOREACH_TO_FLAGS(sticky_toggle); updateStatusMessage(); }
void FlagStatus::sticky_clear(void) {
for (int i = 0; item_[i].flag_ != ModifierFlag::NONE; ++i) {
item_[i].sticky_decrease();
}
updateStatusMessage();
}
void FlagStatus::lock_toggle(Flags flags) { FOREACH_TO_FLAGS(lock_toggle); updateStatusMessage(); }
void FlagStatus::sticky_decrease(Flags flags) { FOREACH_TO_FLAGS(sticky_decrease); updateStatusMessage(); }
MainWindow::MainWindow(QWidget *parent) :
QWidget(parent),
_ui(new Ui::MainWindow),
_tarsnapLogo(this),
_menuBar(NULL),
_appMenu(NULL),
_actionAbout(this),
_useSIPrefixes(false),
_purgeTimerCount(0),
_purgeCountdownWindow(this)
{
_ui->setupUi(this);
_ui->backupListWidget->setAttribute(Qt::WA_MacShowFocusRect, false);
_ui->archiveListWidget->setAttribute(Qt::WA_MacShowFocusRect, false);
_ui->jobListWidget->setAttribute(Qt::WA_MacShowFocusRect, false);
QPixmap logo(":/resources/icons/tarsnap.png");
_tarsnapLogo.setPixmap(logo.scaled(200, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation));
_tarsnapLogo.adjustSize();
_tarsnapLogo.lower();
_tarsnapLogo.show();
Ui::aboutWidget aboutUi;
aboutUi.setupUi(&_aboutWindow);
aboutUi.versionLabel->setText(tr("version ") + QCoreApplication::applicationVersion());
_aboutWindow.setWindowFlags(Qt::CustomizeWindowHint|Qt::WindowCloseButtonHint);
connect(aboutUi.checkUpdateButton, &QPushButton::clicked,
[=](){
QDesktopServices::openUrl(QUrl("https://github.com/Tarsnap/tarsnap-gui/releases"));
});
if(_menuBar.isNativeMenuBar())
{
_actionAbout.setMenuRole(QAction::AboutRole);
connect(&_actionAbout, SIGNAL(triggered()), &_aboutWindow, SLOT(show()));
_appMenu.addAction(&_actionAbout);
_menuBar.addMenu(&_appMenu);
}
connect(_ui->aboutButton, SIGNAL(clicked()), &_aboutWindow, SLOT(show()));
_ui->mainContentSplitter->setCollapsible(0, false);
_ui->journalLog->hide();
_ui->archiveDetailsWidget->hide();
_ui->jobDetailsWidget->hide();
connect(&Debug::instance(), SIGNAL(message(QString)), this , SLOT(appendToConsoleLog(QString))
, Qt::QueuedConnection);
loadSettings();
// Ui actions
_ui->mainTabWidget->setCurrentWidget(_ui->backupTab);
_ui->settingsToolbox->setCurrentWidget(_ui->settingsAccountPage);
_ui->archiveListWidget->addAction(_ui->actionRefresh);
connect(_ui->actionRefresh, SIGNAL(triggered()), _ui->archiveListWidget
, SIGNAL(getArchiveList()), Qt::QueuedConnection);
_ui->backupListWidget->addAction(_ui->actionClearList);
connect(_ui->actionClearList, SIGNAL(triggered()), _ui->backupListWidget
, SLOT(clear()), Qt::QueuedConnection);
_ui->backupListWidget->addAction(_ui->actionBrowseItems);
connect(_ui->actionBrowseItems, SIGNAL(triggered()), this, SLOT(browseForBackupItems()));
_ui->jobListWidget->addAction(_ui->actionAddJob);
connect(_ui->actionAddJob, SIGNAL(triggered()), this, SLOT(addJobClicked()));
_ui->jobListWidget->addAction(_ui->actionJobBackup);
connect(_ui->actionJobBackup, SIGNAL(triggered()), _ui->jobListWidget, SLOT(backupSelectedItems()));
_ui->settingsTab->addAction(_ui->actionRefreshStats);
connect(_ui->actionRefreshStats, SIGNAL(triggered()), this, SIGNAL(getOverallStats()));
this->addAction(_ui->actionGoBackup);
this->addAction(_ui->actionGoBrowse);
this->addAction(_ui->actionGoJobs);
this->addAction(_ui->actionGoSettings);
this->addAction(_ui->actionGoHelp);
connect(_ui->actionGoBackup, &QAction::triggered,
[=](){
_ui->mainTabWidget->setCurrentWidget(_ui->backupTab);
});
connect(_ui->actionGoBrowse, &QAction::triggered,
[=](){
_ui->mainTabWidget->setCurrentWidget(_ui->archivesTab);
});
connect(_ui->actionGoJobs, &QAction::triggered,
[=](){
_ui->mainTabWidget->setCurrentWidget(_ui->jobsTab);
});
connect(_ui->actionGoSettings, &QAction::triggered,
[=](){
_ui->mainTabWidget->setCurrentWidget(_ui->settingsTab);
});
connect(_ui->actionGoHelp, &QAction::triggered,
[=](){
_ui->mainTabWidget->setCurrentWidget(_ui->helpTab);
});
connect(_ui->backupListInfoLabel, SIGNAL(linkActivated(QString)), this,
SLOT(browseForBackupItems()));
connect(_ui->backupButton, SIGNAL(clicked()), this, SLOT(backupButtonClicked()));
connect(_ui->appendTimestampCheckBox, SIGNAL(toggled(bool)), this, SLOT(appendTimestampCheckBoxToggled(bool)));
connect(_ui->accountMachineUseHostnameButton, SIGNAL(clicked()), this, SLOT(accountMachineUseHostnameButtonClicked()));
connect(_ui->accountMachineKeyBrowseButton, SIGNAL(clicked()), this, SLOT(accountMachineKeyBrowseButtonClicked()));
connect(_ui->tarsnapPathBrowseButton, SIGNAL(clicked()), this, SLOT(tarsnapPathBrowseButtonClicked()));
connect(_ui->tarsnapCacheBrowseButton, SIGNAL(clicked()), this, SLOT(tarsnapCacheBrowseButton()));
connect(_ui->repairCacheButton, SIGNAL(clicked()), this, SLOT(repairCacheButtonClicked()));
connect(_ui->purgeArchivesButton, SIGNAL(clicked()), this, SLOT(purgeArchivesButtonClicked()));
connect(_ui->runSetupWizard, SIGNAL(clicked()), this, SLOT(runSetupWizardClicked()));
connect(_ui->expandJournalButton, SIGNAL(toggled(bool)), this, SLOT(expandJournalButtonToggled(bool)));
connect(_ui->downloadsDirBrowseButton, SIGNAL(clicked()), this, SLOT(downloadsDirBrowseButtonClicked()));
connect(_ui->busyWidget, SIGNAL(clicked()), this, SLOT(cancelRunningTasks()));
connect(&_purgeTimer, SIGNAL(timeout()), this, SLOT(purgeTimerFired()));
// Settings page
connect(_ui->accountUserLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->accountMachineLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->accountMachineKeyLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->tarsnapPathLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->tarsnapCacheLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->aggressiveNetworkingCheckBox, SIGNAL(toggled(bool)), this, SLOT(commitSettings()));
connect(_ui->accountMachineKeyLineEdit, SIGNAL(textChanged(QString)), this, SLOT(validateMachineKeyPath()));
connect(_ui->tarsnapPathLineEdit, SIGNAL(textChanged(QString)), this, SLOT(validateTarsnapPath()));
connect(_ui->tarsnapCacheLineEdit, SIGNAL(textChanged(QString)), this, SLOT(validateTarsnapCache()));
connect(_ui->siPrefixesCheckBox, SIGNAL(toggled(bool)), this, SLOT(commitSettings()));
connect(_ui->preservePathsCheckBox, SIGNAL(toggled(bool)), this, SLOT(commitSettings()));
connect(_ui->downloadsDirLineEdit, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
connect(_ui->traverseMountCheckBox, SIGNAL(toggled(bool)), this, SLOT(commitSettings()));
connect(_ui->followSymLinksCheckBox, SIGNAL(toggled(bool)), this, SLOT(commitSettings()));
connect(_ui->skipFilesSpinBox, SIGNAL(editingFinished()), this, SLOT(commitSettings()));
// Backup and Browse
connect(_ui->backupListWidget, SIGNAL(itemTotals(qint64,qint64)), this
, SLOT(updateBackupItemTotals(qint64, qint64)));
connect(_ui->archiveListWidget, SIGNAL(getArchiveList()), this, SIGNAL(getArchiveList()));
connect(this, SIGNAL(archiveList(QList<ArchivePtr >))
, _ui->archiveListWidget, SLOT(addArchives(QList<ArchivePtr >)));
connect(_ui->archiveListWidget, SIGNAL(inspectArchive(ArchivePtr)), this
, SLOT(displayInspectArchive(ArchivePtr)));
connect(_ui->archiveListWidget, SIGNAL(deleteArchives(QList<ArchivePtr>)), this
, SIGNAL(deleteArchives(QList<ArchivePtr>)));
connect(_ui->archiveListWidget, SIGNAL(restoreArchive(ArchivePtr,ArchiveRestoreOptions)),
this, SIGNAL(restoreArchive(ArchivePtr,ArchiveRestoreOptions)));
connect(_ui->mainTabWidget, SIGNAL(currentChanged(int)), this, SLOT(currentPaneChanged(int)));
// Jobs
connect(_ui->addJobButton, SIGNAL(clicked()), this, SLOT(addJobClicked()), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(cancel()), this, SLOT(hideJobDetails()), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(jobAdded(JobPtr)), _ui->jobListWidget, SLOT(addJob(JobPtr)), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(jobAdded(JobPtr)), this, SLOT(displayJobDetails(JobPtr)), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(inspectJobArchive(ArchivePtr)), this, SLOT(displayInspectArchive(ArchivePtr)), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(restoreJobArchive(ArchivePtr,ArchiveRestoreOptions)), this, SIGNAL(restoreArchive(ArchivePtr,ArchiveRestoreOptions)), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(deleteJobArchives(QList<ArchivePtr>)), this, SIGNAL(deleteArchives(QList<ArchivePtr>)), Qt::QueuedConnection);
connect(_ui->jobDetailsWidget, SIGNAL(enableSave(bool)), _ui->addJobButton, SLOT(setEnabled(bool)), Qt::QueuedConnection);
connect(_ui->jobListWidget, SIGNAL(displayJobDetails(JobPtr)), this, SLOT(displayJobDetails(JobPtr)), Qt::QueuedConnection);
connect(_ui->jobListWidget, SIGNAL(backupJob(BackupTaskPtr)), this, SIGNAL(backupNow(BackupTaskPtr)), Qt::QueuedConnection);
connect(_ui->jobListWidget, SIGNAL(restoreArchive(ArchivePtr,ArchiveRestoreOptions)), this, SIGNAL(restoreArchive(ArchivePtr,ArchiveRestoreOptions)), Qt::QueuedConnection);
connect(_ui->jobListWidget, SIGNAL(deleteJobArchives(QList<ArchivePtr>)), this, SIGNAL(deleteArchives(QList<ArchivePtr>)), Qt::QueuedConnection);
//lambda slots to quickly update various UI components
connect(_ui->archiveListWidget, &ArchiveListWidget::getArchiveList,
[=](){updateStatusMessage(tr("Refreshing archives list..."));});
connect(this, &MainWindow::archiveList,
[=](){updateStatusMessage(tr("Refreshing archives list...done"));});
connect(this, &MainWindow::loadArchiveStats,
[=](const ArchivePtr archive){updateStatusMessage(tr("Fetching details for archive <i>%1</i>.").arg(archive->name()));});
connect(this, &MainWindow::loadArchiveContents,
[=](const ArchivePtr archive){updateStatusMessage(tr("Fetching contents for archive <i>%1</i>.").arg(archive->name()));});
connect(_ui->archiveListWidget, &ArchiveListWidget::deleteArchives,
[=](const QList<ArchivePtr> archives){archivesDeleted(archives,false);});
connect(_ui->backupNameLineEdit, &QLineEdit::textChanged,
[=](const QString text){
if(text.isEmpty())
{
_ui->backupButton->setEnabled(false);
_ui->appendTimestampCheckBox->setChecked(false);
}
else if(_ui->backupListWidget->count())
{
_ui->backupButton->setEnabled(true);
}
});
connect(this, &MainWindow::restoreArchive,
[=](const ArchivePtr archive){updateStatusMessage(tr("Restoring archive <i>%1</i>...").arg(archive->name()));});
connect(_ui->downloadsDirLineEdit, &QLineEdit::textChanged,
[=](){
QFileInfo file(_ui->downloadsDirLineEdit->text());
if(file.exists() && file.isDir() && file.isWritable())
_ui->downloadsDirLineEdit->setStyleSheet("QLineEdit{color:black;}");
else
_ui->downloadsDirLineEdit->setStyleSheet("QLineEdit{color:red;}");
});
connect(_ui->jobListWidget, &JobListWidget::backupJob,
[=](BackupTaskPtr backup){
connect(backup, SIGNAL(statusUpdate(const TaskStatus&)), this, SLOT(backupTaskUpdate(const TaskStatus&)), Qt::QueuedConnection);
});
void FlagStatus::lock_decrease(Flags flags) { FOREACH_TO_FLAGS(lock_decrease); updateStatusMessage(); }
void FlagStatus::reset(void) {
for (size_t i = 0; i < item_.size(); ++i) {
item_[i].reset();
}
updateStatusMessage();
}
void FlagStatus::set(KeyCode key, Flags flags) {
for (size_t i = 0; i < item_.size(); ++i) {
item_[i].set(key, flags);
}
updateStatusMessage();
}
bool WelcomeDialog::keyPressEvent(QKeyEvent *event)
{
if (GetFocusWidget()->keyPressEvent(event))
return true;
bool handled = false;
QStringList actions;
handled = GetMythMainWindow()->TranslateKeyPress("Welcome", event, actions);
for (int i = 0; i < actions.size() && !handled; i++)
{
QString action = actions[i];
handled = true;
if (action == "ESCAPE")
{
return true; // eat escape key
}
else if (action == "MENU")
{
showMenu();
}
else if (action == "NEXTVIEW")
{
Close();
}
else if (action == "INFO")
{
MythWelcomeSettings settings;
if (kDialogCodeAccepted == settings.exec())
{
gCoreContext->SendMessage("CLEAR_SETTINGS_CACHE");
updateStatus();
updateScreen();
m_dateFormat = gCoreContext->GetSetting("MythWelcomeDateFormat", "dddd\\ndd MMM yyyy");
m_dateFormat.replace("\\n", "\n");
}
}
else if (action == "SHOWSETTINGS")
{
MythShutdownSettings settings;
if (kDialogCodeAccepted == settings.exec())
gCoreContext->SendMessage("CLEAR_SETTINGS_CACHE");
}
else if (action == "0")
{
QString mythshutdown_status =
m_installDir + "/bin/mythshutdown --status 0";
QString mythshutdown_unlock =
m_installDir + "/bin/mythshutdown --unlock";
QString mythshutdown_lock =
m_installDir + "/bin/mythshutdown --lock";
uint statusCode;
statusCode = myth_system(mythshutdown_status + logPropagateArgs);
// is shutdown locked by a user
if (!(statusCode & 0xFF00) && statusCode & 16)
{
myth_system(mythshutdown_unlock + logPropagateArgs);
}
else
{
myth_system(mythshutdown_lock + logPropagateArgs);
}
updateStatusMessage();
updateScreen();
}
else if (action == "STARTXTERM")
{
QString cmd = gCoreContext->GetSetting("MythShutdownXTermCmd", "");
if (!cmd.isEmpty())
myth_system(cmd);
}
else if (action == "STARTSETUP")
{
QString mythtv_setup = m_installDir + "/bin/mythtv-setup";
myth_system(mythtv_setup + logPropagateArgs);
}
else
handled = false;
}
if (!handled && MythScreenType::keyPressEvent(event))
handled = true;
return handled;
}
void WelcomeDialog::updateStatus(void)
{
checkConnectionToServer();
updateStatusMessage();
}
void WelcomeDialog::customEvent(QEvent *e)
{
if ((MythEvent::Type)(e->type()) == MythEvent::MythEventMessage)
{
MythEvent *me = (MythEvent *) e;
if (me->Message().left(21) == "RECORDING_LIST_CHANGE" ||
me->Message() == "UPDATE_PROG_INFO")
{
LOG(VB_GENERAL, LOG_NOTICE,
"MythWelcome received a recording list change event");
QMutexLocker lock(&m_RecListUpdateMuxtex);
if (pendingRecListUpdate())
{
LOG(VB_GENERAL, LOG_NOTICE,
" [deferred to pending handler]");
}
else
{
// we can't query the backend from inside a customEvent
QTimer::singleShot(500, this, SLOT(updateRecordingList()));
setPendingRecListUpdate(true);
}
}
else if (me->Message().left(15) == "SCHEDULE_CHANGE")
{
LOG(VB_GENERAL, LOG_NOTICE,
"MythWelcome received a SCHEDULE_CHANGE event");
QMutexLocker lock(&m_SchedUpdateMuxtex);
if (pendingSchedUpdate())
{
LOG(VB_GENERAL, LOG_NOTICE,
" [deferred to pending handler]");
}
else
{
QTimer::singleShot(500, this, SLOT(updateScheduledList()));
setPendingSchedUpdate(true);
}
}
else if (me->Message().left(18) == "SHUTDOWN_COUNTDOWN")
{
#if 0
LOG(VB_GENERAL, LOG_NOTICE,
"MythWelcome received a SHUTDOWN_COUNTDOWN event");
#endif
QString secs = me->Message().mid(19);
m_secondsToShutdown = secs.toInt();
updateStatusMessage();
updateScreen();
}
else if (me->Message().left(12) == "SHUTDOWN_NOW")
{
LOG(VB_GENERAL, LOG_NOTICE,
"MythWelcome received a SHUTDOWN_NOW event");
if (gCoreContext->IsFrontendOnly())
{
// does the user want to shutdown this frontend only machine
// when the BE shuts down?
if (gCoreContext->GetNumSetting("ShutdownWithMasterBE", 0) == 1)
{
LOG(VB_GENERAL, LOG_NOTICE,
"MythWelcome is shutting this computer down now");
QString poweroff_cmd = gCoreContext->GetSetting("MythShutdownPowerOff", "");
if (!poweroff_cmd.isEmpty())
myth_system(poweroff_cmd);
}
}
}
}
}
void NetworkManipulationTool::activate(NetworkVisualization *visu) {
mVisuContext = visu;
updateStatusMessage(getStatusMessage());
}
DebuggerMainWnd::DebuggerMainWnd() :
KXmlGuiWindow(),
m_debugger(0),
#ifdef GDB_TRANSCRIPT
m_transcriptFile(GDB_TRANSCRIPT),
#endif
m_outputTermCmdStr(defaultTermCmdStr),
m_outputTermProc(new QProcess),
m_ttyLevel(-1), /* no tty yet */
m_popForeground(false),
m_backTimeout(1000),
m_tabWidth(0),
m_sourceFilter(defaultSourceFilter),
m_headerFilter(defaultHeaderFilter),
m_animation(0),
m_statusActive(i18n("active"))
{
setDockNestingEnabled(true);
m_filesWindow = new WinStack(this);
setCentralWidget(m_filesWindow);
QDockWidget* dw1 = createDockWidget("Stack", i18n("Stack"));
m_btWindow = new QListWidget(dw1);
dw1->setWidget(m_btWindow);
QDockWidget* dw2 = createDockWidget("Locals", i18n("Locals"));
m_localVariables = new ExprWnd(dw2, i18n("Variable"));
dw2->setWidget(m_localVariables);
QDockWidget* dw3 = createDockWidget("Watches", i18n("Watches"));
m_watches = new WatchWindow(dw3);
dw3->setWidget(m_watches);
QDockWidget* dw4 = createDockWidget("Registers", i18n("Registers"));
m_registers = new RegisterView(dw4);
dw4->setWidget(m_registers);
QDockWidget* dw5 = createDockWidget("Breakpoints", i18n("Breakpoints"));
m_bpTable = new BreakpointTable(dw5);
dw5->setWidget(m_bpTable);
QDockWidget* dw6 = createDockWidget("Output", i18n("Output"));
m_ttyWindow = new TTYWindow(dw6);
dw6->setWidget(m_ttyWindow);
QDockWidget* dw7 = createDockWidget("Threads", i18n("Threads"));
m_threads = new ThreadList(dw7);
dw7->setWidget(m_threads);
QDockWidget* dw8 = createDockWidget("Memory", i18n("Memory"));
m_memoryWindow = new MemoryWindow(dw8);
dw8->setWidget(m_memoryWindow);
m_debugger = new KDebugger(this, m_localVariables, m_watches->watchVariables(), m_btWindow);
connect(m_debugger, SIGNAL(updateStatusMessage()), SLOT(slotNewStatusMsg()));
connect(m_debugger, SIGNAL(updateUI()), SLOT(updateUI()));
connect(m_debugger, SIGNAL(breakpointsChanged()), SLOT(updateLineItems()));
connect(m_debugger, SIGNAL(debuggerStarting()), SLOT(slotDebuggerStarting()));
m_bpTable->setDebugger(m_debugger);
m_memoryWindow->setDebugger(m_debugger);
setStandardToolBarMenuEnabled(true);
initKAction();
initStatusBar();
connect(m_watches, SIGNAL(addWatch()), SLOT(slotAddWatch()));
connect(m_watches, SIGNAL(deleteWatch()), m_debugger, SLOT(slotDeleteWatch()));
connect(m_watches, SIGNAL(textDropped(const QString&)), SLOT(slotAddWatch(const QString&)));
connect(&m_filesWindow->m_findDlg, SIGNAL(closed()), SLOT(updateUI()));
connect(m_filesWindow, SIGNAL(newFileLoaded()),
SLOT(slotNewFileLoaded()));
connect(m_filesWindow, SIGNAL(toggleBreak(const QString&,int,const DbgAddr&,bool)),
this, SLOT(slotToggleBreak(const QString&,int,const DbgAddr&,bool)));
connect(m_filesWindow, SIGNAL(enadisBreak(const QString&,int,const DbgAddr&)),
this, SLOT(slotEnaDisBreak(const QString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)),
m_filesWindow, SLOT(activate(const QString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(executableUpdated()),
m_filesWindow, SLOT(reloadAllFiles()));
connect(m_debugger, SIGNAL(updatePC(const QString&,int,const DbgAddr&,int)),
m_filesWindow, SLOT(updatePC(const QString&,int,const DbgAddr&,int)));
// value popup communication
connect(m_filesWindow, SIGNAL(initiateValuePopup(const QString&)),
m_debugger, SLOT(slotValuePopup(const QString&)));
connect(m_debugger, SIGNAL(valuePopup(const QString&)),
m_filesWindow, SLOT(slotShowValueTip(const QString&)));
// disassembling
connect(m_filesWindow, SIGNAL(disassemble(const QString&, int)),
m_debugger, SLOT(slotDisassemble(const QString&, int)));
connect(m_debugger, SIGNAL(disassembled(const QString&,int,const std::list<DisassembledCode>&)),
m_filesWindow, SLOT(slotDisassembled(const QString&,int,const std::list<DisassembledCode>&)));
connect(m_filesWindow, SIGNAL(moveProgramCounter(const QString&,int,const DbgAddr&)),
m_debugger, SLOT(setProgramCounter(const QString&,int,const DbgAddr&)));
// program stopped
connect(m_debugger, SIGNAL(programStopped()), SLOT(slotProgramStopped()));
connect(&m_backTimer, SIGNAL(timeout()), SLOT(slotBackTimer()));
// tab width
connect(this, SIGNAL(setTabWidth(int)), m_filesWindow, SIGNAL(setTabWidth(int)));
// connect breakpoint table
connect(m_bpTable, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)),
m_filesWindow, SLOT(activate(const QString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(updateUI()), m_bpTable, SLOT(updateUI()));
connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateBreakList()));
connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateUI()));
connect(m_debugger, SIGNAL(registersChanged(const std::list<RegisterInfo>&)),
m_registers, SLOT(updateRegisters(const std::list<RegisterInfo>&)));
connect(m_debugger, SIGNAL(memoryDumpChanged(const QString&, const std::list<MemoryDump>&)),
m_memoryWindow, SLOT(slotNewMemoryDump(const QString&, const std::list<MemoryDump>&)));
connect(m_debugger, SIGNAL(saveProgramSpecific(KConfigBase*)),
m_memoryWindow, SLOT(saveProgramSpecific(KConfigBase*)));
connect(m_debugger, SIGNAL(restoreProgramSpecific(KConfigBase*)),
m_memoryWindow, SLOT(restoreProgramSpecific(KConfigBase*)));
// thread window
connect(m_debugger, SIGNAL(threadsChanged(const std::list<ThreadInfo>&)),
m_threads, SLOT(updateThreads(const std::list<ThreadInfo>&)));
connect(m_threads, SIGNAL(setThread(int)),
m_debugger, SLOT(setThread(int)));
// popup menu of the local variables window
m_localVariables->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_localVariables, SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(slotLocalsPopup(const QPoint&)));
makeDefaultLayout();
setupGUI(KXmlGuiWindow::Default, "kdbgui.rc");
restoreSettings(KGlobal::config());
// The animation button is not part of the restored window state.
// We must create it after the toolbar was loaded.
initAnimation();
updateUI();
m_bpTable->updateUI();
}
LRESULT CCEGLView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bProcessed = FALSE;
switch (message)
{
case WM_LBUTTONDOWN:
#if(_MSC_VER >= 1600)
// Don't process message generated by Windows Touch
if (m_bSupportTouch && (s_pfGetMessageExtraInfoFunction() & MOUSEEVENTF_FROMTOUCH) == MOUSEEVENTF_FROMTOUCH) break;
#endif /* #if(_MSC_VER >= 1600) */
#ifdef Hunter
m_measureRect = true;
m_mouse1x = (short)LOWORD(lParam) / m_fFrameZoomFactor;
m_mouse1y = (short)HIWORD(lParam) / m_fFrameZoomFactor;
#endif // Hunter
if (m_pDelegate && MK_LBUTTON == wParam)
{
POINT point = {(short)LOWORD(lParam), (short)HIWORD(lParam)};
CCPoint pt(point.x, point.y);
pt.x /= m_fFrameZoomFactor;
pt.y /= m_fFrameZoomFactor;
CCPoint tmp = ccp(pt.x, m_obScreenSize.height - pt.y);
if (m_obViewPortRect.equals(CCRectZero) || m_obViewPortRect.containsPoint(tmp))
{
m_bCaptured = true;
SetCapture(m_hWnd);
int id = 0;
handleTouchesBegin(1, &id, &pt.x, &pt.y);
}
}
break;
case WM_MOUSEMOVE:
#if(_MSC_VER >= 1600)
// Don't process message generated by Windows Touch
if (m_bSupportTouch && (s_pfGetMessageExtraInfoFunction() & MOUSEEVENTF_FROMTOUCH) == MOUSEEVENTF_FROMTOUCH) break;
#endif /* #if(_MSC_VER >= 1600) */
if (MK_LBUTTON == wParam && m_bCaptured)
{
POINT point = {(short)LOWORD(lParam), (short)HIWORD(lParam)};
CCPoint pt(point.x, point.y);
int id = 0;
pt.x /= m_fFrameZoomFactor;
pt.y /= m_fFrameZoomFactor;
handleTouchesMove(1, &id, &pt.x, &pt.y);
}
#ifdef Hunter
{
POINT point22 = {(short)LOWORD(lParam), (short)HIWORD(lParam)};
int m2x = 0, m2y = 0, m1x = 0, m1y = 0;
m1x = point22.x / m_fFrameZoomFactor;
m1y = point22.y / m_fFrameZoomFactor;
if (m_measureRect)
{
m2x = point22.x / m_fFrameZoomFactor;
m2y = point22.y / m_fFrameZoomFactor;
}
if(m2x != m_mouse2x || m1x != m_mouse1x || m1y != m_mouse1y || m_mouse2y != m2y)
{
m_mouse2x = m2x;
m_mouse2y = m2y;
if(!m_measureRect)
{
m_mouse1x = m1x;
m_mouse1y = m1y;
}
updateStatusMessage();
}
}
#endif // Hunter
break;
case WM_LBUTTONUP:
#if(_MSC_VER >= 1600)
// Don't process message generated by Windows Touch
if (m_bSupportTouch && (s_pfGetMessageExtraInfoFunction() & MOUSEEVENTF_FROMTOUCH) == MOUSEEVENTF_FROMTOUCH) break;
#endif /* #if(_MSC_VER >= 1600) */
#ifdef Hunter
m_measureRect = false;
#endif // Hunter
if (m_bCaptured)
{
POINT point = {(short)LOWORD(lParam), (short)HIWORD(lParam)};
CCPoint pt(point.x, point.y);
int id = 0;
pt.x /= m_fFrameZoomFactor;
pt.y /= m_fFrameZoomFactor;
handleTouchesEnd(1, &id, &pt.x, &pt.y);
ReleaseCapture();
m_bCaptured = false;
}
break;
#if(_MSC_VER >= 1600)
case WM_TOUCH:
{
BOOL bHandled = FALSE;
UINT cInputs = LOWORD(wParam);
PTOUCHINPUT pInputs = new TOUCHINPUT[cInputs];
if (pInputs)
{
if (s_pfGetTouchInputInfoFunction((HTOUCHINPUT)lParam, cInputs, pInputs, sizeof(TOUCHINPUT)))
{
for (UINT i=0; i < cInputs; i++)
{
TOUCHINPUT ti = pInputs[i];
POINT input;
input.x = TOUCH_COORD_TO_PIXEL(ti.x);
input.y = TOUCH_COORD_TO_PIXEL(ti.y);
ScreenToClient(m_hWnd, &input);
CCPoint pt(input.x, input.y);
CCPoint tmp = ccp(pt.x, m_obScreenSize.height - pt.y);
if (m_obViewPortRect.equals(CCRectZero) || m_obViewPortRect.containsPoint(tmp))
{
pt.x /= m_fFrameZoomFactor;
pt.y /= m_fFrameZoomFactor;
if (ti.dwFlags & TOUCHEVENTF_DOWN)
handleTouchesBegin(1, reinterpret_cast<int*>(&ti.dwID), &pt.x, &pt.y);
else if (ti.dwFlags & TOUCHEVENTF_MOVE)
handleTouchesMove(1, reinterpret_cast<int*>(&ti.dwID), &pt.x, &pt.y);
else if (ti.dwFlags & TOUCHEVENTF_UP)
handleTouchesEnd(1, reinterpret_cast<int*>(&ti.dwID), &pt.x, &pt.y);
}
}
bHandled = TRUE;
}
delete [] pInputs;
}
if (bHandled)
{
s_pfCloseTouchInputHandleFunction((HTOUCHINPUT)lParam);
}
}
break;
#endif /* #if(_MSC_VER >= 1600) */
case WM_SIZE:
#ifndef GCParticleEditor
switch (wParam)
{
case SIZE_RESTORED:
CCApplication::sharedApplication()->applicationWillEnterForeground();
break;
case SIZE_MINIMIZED:
CCApplication::sharedApplication()->applicationDidEnterBackground();
break;
}
#endif
break;
case WM_KEYDOWN:
if (wParam == VK_F1 || wParam == VK_F2)
{
CCDirector* pDirector = CCDirector::sharedDirector();
if (GetKeyState(VK_LSHIFT) < 0 || GetKeyState(VK_RSHIFT) < 0 || GetKeyState(VK_SHIFT) < 0)
pDirector->getKeypadDispatcher()->dispatchKeypadMSG(wParam == VK_F1 ? kTypeBackClicked : kTypeMenuClicked);
}
else if (wParam == VK_ESCAPE)
{
CCDirector::sharedDirector()->getKeypadDispatcher()->dispatchKeypadMSG(kTypeBackClicked);
}
#ifdef Hunter
else
{
CCDirector::sharedDirector()->getKeypadDispatcher()->win32KeyboardMSG(message, wParam);
}
#endif // Hunter
if ( m_lpfnAccelerometerKeyHook!=NULL )
{
(*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );
}
break;
#ifdef Hunter
case WM_SYSKEYDOWN:
{
DWORD dwFlags = (DWORD)lParam;
if(0x20000000 & dwFlags)
{
if(wParam == VK_RETURN)
{
CCLOG("wParam is %d", wParam);
CCLOG("lParam is %d", lParam);
DWORD info = GetWindowLong(m_hWnd, GWL_STYLE);
if((info & WS_POPUP) > 0)
{
setWindowsSize(true, 1136, 640);
} else
{
setWindowsSize(false, 1136, 640);
}
}
}
}
break;
#endif
case WM_KEYUP:
#ifdef Hunter
CCDirector::sharedDirector()->getKeypadDispatcher()->win32KeyboardMSG(message, wParam);
#endif // Hunter
if ( m_lpfnAccelerometerKeyHook!=NULL )
{
(*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );
}
break;
case WM_CHAR:
{
if (wParam < 0x20)
{
if (VK_BACK == wParam)
{
CCIMEDispatcher::sharedDispatcher()->dispatchDeleteBackward();
}
else if (VK_RETURN == wParam)
{
CCIMEDispatcher::sharedDispatcher()->dispatchInsertText("\n", 1);
}
else if (VK_TAB == wParam)
{
// tab input
}
else if (VK_ESCAPE == wParam)
{
// ESC input
//CCDirector::sharedDirector()->end();
}
}
else if (wParam < 128)
{
// ascii char
CCIMEDispatcher::sharedDispatcher()->dispatchInsertText((const char *)&wParam, 1);
}
else
{
char szUtf8[8] = {0};
int nLen = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)&wParam, 1, szUtf8, sizeof(szUtf8), NULL, NULL);
CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(szUtf8, nLen);
}
if ( m_lpfnAccelerometerKeyHook!=NULL )
{
(*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );
}
}
break;
case WM_PAINT:
PAINTSTRUCT ps;
BeginPaint(m_hWnd, &ps);
EndPaint(m_hWnd, &ps);
break;
case WM_CLOSE:
CCDirector::sharedDirector()->end();
break;
case WM_DESTROY:
destroyGL();
PostQuitMessage(0);
break;
default:
if (m_wndproc)
{
m_wndproc(message, wParam, lParam, &bProcessed);
if (bProcessed) break;
}
return DefWindowProc(m_hWnd, message, wParam, lParam);
}
if (m_wndproc && !bProcessed)
{
m_wndproc(message, wParam, lParam, &bProcessed);
}
return 0;
}
void DownloadManager::clear() {
qDeleteAll(items);
items.clear();
updateStatusMessage();
}