def saveSettings(self):
s = QSettings(OrganizationName, ApplicationName)
s.beginWriteArray('ChannelSettings')
t = self.channelTable
for ch in range( t.rowCount() ) :
s.setArrayIndex(ch)
gainCombo = t.cellWidget(ch, self.columns['gain'])
couplingCombo = t.cellWidget(ch, self.columns['coupling'])
modeCombo = t.cellWidget(ch, self.columns['mode'])
squidCombo = t.cellWidget(ch, self.columns['squid'])
s.setValue('enabled', t.cellWidget(ch, self.columns['enabled']).isChecked())
s.setValue('save', t.cellWidget(ch, self.columns['save']).isChecked())
s.setValue('coupling', couplingCombo.currentText())
s.setValue('mode', modeCombo.currentText())
s.setValue('gain', gainCombo.itemData(gainCombo.currentIndex()))
s.setValue('squid', squidCombo.currentText())
s.setValue('reset', t.cellWidget(ch, self.columns['reset']).value())
s.setValue('label', t.cellWidget(ch, self.columns['label']).text())
s.endArray()
s.setValue('sampleRate', self.sampleRateSb.value())
s.setValue('chunkTime', self.chunkTimeSb.value())
s.setValue('name', self.nameLe.text())
s.setValue('comment', self.commentLe.text())
s.setValue('lpfOrder', self.lpfOrderSb.value())
s.setValue('lpfFrequency', self.lpfFrequencySb.value())
s.setValue('resampleRateSb', self.resampleRateSb.value())
s.setValue('enablePlotting', self.enablePlottingCb.isChecked())
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
config_size = settings.value("script_assistant/size")
if config_size is None:
if gui.settings_manager.load_setting("current_configuration"):
pass
else:
gui.settings_manager.save_setting("current_configuration",
"Script Assistant")
gui.settings_manager.save_setting("script_folder", "")
gui.settings_manager.save_setting(
"test_folder", os.path.join(__location__, "tests"))
gui.settings_manager.save_setting("test_data_folder", "")
gui.settings_manager.save_setting("no_reload", "N")
gui.settings_manager.save_setting("current_test", "$ALL")
settings.beginWriteArray("script_assistant")
settings.setArrayIndex(0)
settings.setValue("configuration", "Script Assistant")
settings.setValue("script_folder", "")
settings.setValue("test_data_folder", "")
settings.setValue("test_folder",
os.path.join(__location__, "tests"))
settings.setValue("no_reload", "N")
settings.endArray()
self.create_reload_action()
self.create_test_tool_button()
self.create_add_test_data_action()
self.create_settings_action()
def saveinfos():
"""Saves the info's."""
s = QSettings()
s.beginWriteArray("lilypondinfo")
for i, info in enumerate(infos()):
s.setArrayIndex(i)
info.write(s)
s.endArray()
def saveinfos():
"""Saves the info's."""
s = QSettings()
s.beginWriteArray("lilypondinfo")
for i, info in enumerate(infos()):
s.setArrayIndex(i)
info.write(s)
s.endArray()
def saveSettings(self):
s = QSettings()
s.beginWriteArray('EMailList')
for row in range(self.emailListWidget.count()):
s.setArrayIndex(row)
item = self.emailListWidget.item(row)
print row, item.checkState(), item.text()
s.setValue('Email', item.text())
s.setValue('Checked', item.checkState())
s.endArray()
def save(self):
# truncate list if necessary
self.__recent_files = self.__recent_files[:MAX_SIZE]
s = QSettings()
s.beginWriteArray("RecentFiles")
cnt = 0
for f in self.__recent_files:
s.setArrayIndex(cnt)
s.setValue("Filename", f)
cnt += 1
s.sync()
def saveConnections(self):
settings = QSettings(self)
settings.beginWriteArray("connections")
for i in range(len(self.connections)):
spojenie = self.connections[i]
settings.setArrayIndex(i)
settings.setValue("local", QVariant(bool(spojenie.local())))
settings.setValue("path", QVariant(str(spojenie.path())))
settings.setValue("host", QVariant(str(spojenie.host())))
settings.setValue("port", QVariant(int(spojenie.port())))
settings.setValue("password", QVariant(str(spojenie.password())))
settings.endArray()
def _saveSettings(self):
settings = QSettings()
settings.remove(self._group)
settings.setValue(self._group + '/' + 'Name', self.name)
settings.beginWriteArray(self._group)
i = 0
for clause in self._clauses:
settings.setArrayIndex(i)
clause.saveSettings(settings)
i += 1
settings.endArray()
self.status = 'loaded'
def _saveSettings(self):
settings = QSettings()
settings.remove(self._group)
settings.setValue(self._group + '/' + 'Name', self.name)
settings.beginWriteArray(self._group)
i = 0
for clause in self._clauses:
settings.setArrayIndex(i)
clause.saveSettings(settings)
i += 1
settings.endArray()
self.status = 'loaded'
def store_profiles(profiles):
settings = QSettings()
settings.beginWriteArray("database_profiles")
for index, info in enumerate(profiles):
settings.setArrayIndex(index)
settings.setValue("profilename", QVariant(encode_setting(info["profilename"])))
settings.setValue("dialect", QVariant(encode_setting(info["dialect"])))
settings.setValue("host", QVariant(encode_setting(info["host"])))
settings.setValue("port", QVariant(encode_setting(info["port"])))
settings.setValue("database", QVariant(encode_setting(info["database"])))
settings.setValue("user", QVariant(encode_setting(info["user"])))
settings.setValue("pass", QVariant(encode_setting(info["pass"])))
settings.endArray()
def saveSettings(self):
s = QSettings()
table = self.currentTable
nRows = table.rowCount()
s.beginWriteArray('currentTable', nRows)
for row in range(nRows):
s.setArrayIndex(row)
s.setValue('enabled', table.cellWidget(row,0).isChecked())
s.setValue('rampRate', table.cellWidget(row,1).value())
s.setValue('target', table.cellWidget(row,2).value())
s.setValue('holdTime', table.cellWidget(row,3).value())
s.endArray()
def writeSettings(self):
settings = QSettings()
settings.beginGroup("MainWindow")
settings.setValue("Size", QVariant(self.size()))
settings.setValue("Pos", QVariant(self.pos()))
settings.endGroup()
settings.beginGroup("BrowsePanel")
settings.setValue("Visible", QVariant(self.browsePanel.isVisible()))
settings.setValue("Floating", QVariant(self.browsePanel.isFloating()))
settings.setValue("Size", QVariant(self.browsePanel.size()))
settings.setValue("Pos", QVariant(self.browsePanel.pos()))
settings.endGroup()
settings.beginGroup("FilterPanel")
settings.setValue("Visible", QVariant(self.filterPanel.isVisible()))
settings.setValue("Floating", QVariant(self.filterPanel.isFloating()))
settings.setValue("Size", QVariant(self.filterPanel.size()))
settings.setValue("Pos", QVariant(self.filterPanel.pos()))
settings.endGroup()
settings.beginGroup("DataView")
settings.setValue("FixedWidthFont", QVariant(self.dataView.isFixedWidthFont()))
settings.endGroup()
settings.beginGroup("FindDialog")
d = self.dataView.findDialog
settings.setValue("Visible", QVariant(d.isVisible()))
settings.setValue("Pos", QVariant(d.pos()))
settings.setValue("Flags", QVariant(d.getFindFlags()))
settings.setValue("WrappedSearch", QVariant(d.getWrappedSearch()))
settings.endGroup()
settings.setValue("IOVs/UTC", QVariant(self.iovUTCCheckBox.isChecked()))
settings.beginWriteArray("Recent")
recents = self.menuRecent.actions()
i = 0
for action in recents:
settings.setArrayIndex(i)
settings.setValue("ConnString", QVariant(action.text()))
i += 1
settings.endArray()
settings.beginGroup("Misc")
settings.setValue("ShowWelcome", QVariant(self._showWelcome))
settings.setValue("ExternalEditor", QVariant(self._externalEditor))
settings.endGroup()
def save_configuration(self):
"""Save configuration (overwrite if config name already exists)."""
new_config = self.cmb_config.lineEdit().text()
if self.chk_reload.isChecked():
no_reload_value = "Y"
else:
no_reload_value = "N"
# Save to system
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
# First get the current size of the config array in QSettings.
size = settings.beginReadArray("script_assistant")
# Check if the config already exists. If it does, overwrite it.
for i in xrange(size):
settings.setArrayIndex(i)
if settings.value("configuration") == new_config:
config_index = i
break
else: # no break
config_index = size
settings.endArray()
# Now create new entry / overwrite (depending on index value).
settings.beginWriteArray("script_assistant")
settings.setArrayIndex(config_index)
settings.setValue("configuration", new_config)
settings.setValue("script_folder", self.lne_script.text())
settings.setValue("test_data_folder", self.lne_test_data.text())
settings.setValue("test_folder", self.lne_test.text())
settings.setValue("no_reload", no_reload_value)
settings.endArray()
config_names = [
self.cmb_config.itemText(i) for i in range(self.cmb_config.count())
]
if new_config not in config_names:
self.cmb_config.addItem(new_config)
self.setWindowTitle("Script Assistant Configuration")
self.btn_save.setEnabled(False)
if self.cmb_config.count() > 0:
self.btn_delete.setEnabled(True)
def store_profiles(profiles):
settings = QSettings()
settings.beginWriteArray('database_profiles')
for index, info in enumerate(profiles):
settings.setArrayIndex(index)
settings.setValue('profilename',
QVariant(encode_setting(info['profilename'])))
settings.setValue('dialect', QVariant(encode_setting(info['dialect'])))
settings.setValue('host', QVariant(encode_setting(info['host'])))
settings.setValue('port', QVariant(encode_setting(info['port'])))
settings.setValue('database',
QVariant(encode_setting(info['database'])))
settings.setValue('user', QVariant(encode_setting(info['user'])))
settings.setValue('pass', QVariant(encode_setting(info['pass'])))
settings.endArray()
def saveSettings(self, s=None):
'''Save table contents to QSettings'''
if s is None:
s = QSettings()
name = self.objectName()
if len(name) == 0:
raise Exception(
'Cannot save settings without objectName property set.')
s.beginWriteArray(name)
for row in range(self.rowCount()):
s.setArrayIndex(row)
for columnName in self.columnNames:
w = self.cellValue(row, columnName)
print row, columnName, w
s.setValue(columnName, w)
s.endArray()
def store(self, iniFile=None, properties=None):
if iniFile is not None:
s = QSettings(iniFile, QSettings.IniFormat)
else:
s = QSettings()
if properties is None:
properties = self.properties()
s.beginGroup('PosiView')
s.remove('Mobiles')
s.remove('DataProvider')
idx = 0
s.beginWriteArray('Mobiles')
try:
for v in properties['Mobiles'].values():
s.setArrayIndex(idx)
for k1, v1 in v.items():
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
idx = 0
s.beginWriteArray('DataProvider')
try:
for v in properties['Provider'].values():
s.setArrayIndex(idx)
for k1, v1 in v.items():
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
s.setValue('Mission/Cruise', properties['Mission']['cruise'])
s.setValue('Mission/Dive', properties['Mission']['dive'])
s.setValue('Mission/Station', properties['Mission']['station'])
s.setValue('Recorder/Path', properties['RecorderPath'])
s.setValue('Recorder/AutoRecord', properties['AutoRecord'])
s.setValue('Misc/NotifyDuration', properties['NotifyDuration'])
s.setValue('Misc/ShowUtcClock', properties['ShowUtcClock'])
s.endGroup()
def store(self, iniFile=None, properties=None):
if iniFile is not None:
s = QSettings(iniFile, QSettings.IniFormat)
else:
s = QSettings()
if properties is None:
properties = self.properties()
s.beginGroup('PosiView')
s.remove('Mobiles')
s.remove('DataProvider')
idx = 0
s.beginWriteArray('Mobiles')
try:
for v in properties['Mobiles'].values():
s.setArrayIndex(idx)
for k1, v1 in v.items():
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
idx = 0
s.beginWriteArray('DataProvider')
try:
for v in properties['Provider'].values():
s.setArrayIndex(idx)
for k1, v1 in v.items():
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
s.setValue('Mission/Cruise', properties['Mission']['cruise'])
s.setValue('Mission/Dive', properties['Mission']['dive'])
s.setValue('Mission/Station', properties['Mission']['station'])
s.setValue('Recorder/Path', properties['RecorderPath'])
s.setValue('Recorder/AutoRecord', properties['AutoRecord'])
s.setValue('Misc/NotifyDuration', properties['NotifyDuration'])
s.setValue('Misc/ShowUtcClock', properties['ShowUtcClock'])
s.endGroup()
def delete_configuration(self):
"""Remove configuration."""
config = self.load_configuration()
delete_config = self.cmb_config.lineEdit().text()
for i in config:
if config[i]["configuration"] == delete_config:
config.pop(i)
self.cmb_config.removeItem(self.cmb_config.currentIndex())
break
else:
self.cmb_config.lineEdit().clear()
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
settings.beginGroup("script_assistant")
settings.remove("")
settings.endGroup()
settings.beginWriteArray("script_assistant")
for i, item in enumerate(config):
settings.setArrayIndex(i)
settings.setValue("configuration", config[item]["configuration"])
settings.setValue("script_folder", config[item]["script_folder"])
settings.setValue("test_data_folder",
config[item]["test_data_folder"])
settings.setValue("test_folder", config[item]["test_folder"])
settings.setValue("no_reload", config[item]["no_reload"])
settings.endArray()
if self.cmb_config.count() == 0:
self.btn_delete.setEnabled(False)
self.lne_script.setText("")
self.lne_test.setText("")
self.lne_test_data.setText("")
self.chk_reload.setChecked(False)
else:
self.show_configuration()
def saveSettings(self):
s = QSettings(OrganizationName, ApplicationName)
s.setValue('geometry', self.saveGeometry())
for w in self.settingsWidgets:
saveWidgetToSettings(s, w)
s.setValue('splitter1State', self.splitter1.saveState())
s.setValue('splitter2State', self.splitter2.saveState())
table = self.table
nRows = table.rowCount()
s.beginWriteArray('frequencyTable', nRows)
w = self.tableCellWidget
for row in range(nRows):
s.setArrayIndex(row)
s.setValue('active', w(row,'active').isChecked())
s.setValue('f', w(row,'f').value())
s.setValue('A', w(row,'A').value())
s.setValue('phase', w(row,'phase').value())
s.setValue('bw', w(row, 'bw').value())
s.setValue('rollOff', w(row, 'order').value())
s.endArray()
def store_settings():
global name, email, place
global ROS_PKGS, ROS_MSGS, ROS_SRVS
settings = QSettings('semCo', 'ROSLab IDE')
# store user information
settings.setValue('name', name)
settings.setValue('email', email)
settings.setValue('place', place)
# store message packages
size = len(ROS_MSGS)
settings.beginWriteArray('msg_packages', size)
for i in range(size):
settings.setArrayIndex(i)
settings.setValue('name', ROS_MSGS[i])
settings.endArray()
# store service packages
size = len(ROS_SRVS)
settings.beginWriteArray('srv_packages', size)
for i in range(size):
settings.setArrayIndex(i)
settings.setValue('name', ROS_SRVS[i])
settings.endArray()
class KhtSettings(QMainWindow):
def __init__(self, parent=None):
global isMAEMO
QMainWindow.__init__(self,parent)
self.parent = parent
try:
self.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
self.setAttribute(Qt.WA_Maemo5StackedWindow, True)
isMAEMO = True
except:
isMAEMO = False
self.setWindowTitle("KhtSync Config")
#Resize window if not maemo
if not isMAEMO:
self.resize(800, 600)
self.settings = QSettings()
self.setupGUI()
self.loadPrefs()
self.setupMenu()
self.accounts_model.set(self.accounts)
self.show()
def isRunning(self):
return os.path.isfile('/tmp/khtsync.pid')
def runorstop(self):
if self.isRunning():
os.system('/usr/bin/python ' + DAEMON_PATH + ' stop')
self.daemon_button.setText('Run')
else:
os.system('/usr/bin/python ' + DAEMON_PATH + ' start')
self.daemon_button.setText('Stop')
def loadPrefs(self):
if self.settings.contains('refresh_interval'):
self.refresh_interval.setValue(int(self.settings.value('refresh_interval')))
#Load account
self.accounts = []
nb_accounts = self.settings.beginReadArray('accounts')
for index in range(nb_accounts):
self.settings.setArrayIndex(index)
self.accounts.append(SSHSyncAccount(hostname=self.settings.value('hostname'), \
port=int(self.settings.value('port')), \
username=self.settings.value('username'), \
password=self.settings.value('password'), \
local_dir=self.settings.value('local_dir'), \
remote_dir=self.settings.value('remote_dir')))
self.settings.endArray()
def savePrefs(self):
self.settings.setValue('refresh_interval',self.refresh_interval.value())
self.settings.beginWriteArray("accounts")
for index,account in enumerate(self.accounts):
self.settings.setArrayIndex(index)
self.settings.setValue("hostname", account.hostname)
self.settings.setValue("port", account.port )
self.settings.setValue("username", account.username )
self.settings.setValue("password", account.password )
self.settings.setValue("local_dir", account.local_dir )
self.settings.setValue("remote_dir", account.remote_dir )
self.settings.endArray()
self.settings.sync()
def closeEvent(self,widget,*args):
self.savePrefs()
def setupGUI(self):
global isMAEMO
self.aWidget = QWidget(self)
self._rmain_layout = QVBoxLayout(self.aWidget)
self._main_layout = QGridLayout()
self.aWidget.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Expanding)
gridIndex = 0
if self.isRunning():
self.daemon_button = QPushButton('Stop')
else:
self.daemon_button = QPushButton('Run')
self.daemon_button.clicked.connect(self.runorstop)
self._main_layout.addWidget(self.daemon_button,gridIndex,0)
self.show_log = QPushButton('Show logs')
self.show_log.clicked.connect(self.showlog)
self._main_layout.addWidget(self.show_log,gridIndex,1)
gridIndex += 1
self._main_layout.addWidget(QLabel('Refresh interval (min)'),gridIndex,0)
self.refresh_interval = QSpinBox()
self.refresh_interval.setMinimum(5)
self.refresh_interval.setMaximum(99999)
self._main_layout.addWidget(self.refresh_interval,gridIndex,1)
gridIndex += 1
self.accounts_model = AccountsModel()
self.accounts_view = AccountsView()
self.accounts_view.clicked.connect(self.edit_account)
self.accounts_view.setModel(self.accounts_model)
self._rmain_layout.addLayout(self._main_layout)
self.add_acc_button = QPushButton('Add account')
self.add_acc_button.clicked.connect(self.add_account)
self._rmain_layout.addWidget(self.add_acc_button)
self._rmain_layout.addWidget(self.accounts_view)
self.aWidget.setLayout(self._rmain_layout)
self.setCentralWidget(self.aWidget)
def showlog(self):
import commands
fileHandle = open('/tmp/khtsync.sh', 'wb')
fileHandle.write('#!/bin/sh\n/usr/bin/tail -f /home/user/.khtsync.log\n')
fileHandle.close()
commands.getoutput("chmod +x /tmp/khtsync.sh")
os.system('/usr/bin/osso-xterm /tmp/khtsync.sh')
def add_account(self):
self.accounts.append(SSHSyncAccount())
self.accounts_model.set(self.accounts)
def edit_account(self):
for index in self.accounts_view.selectedIndexes():
account_index = index.row()
self.accountDlg = AccountDialog(self,account_index,self.accounts[account_index])
self.accountDlg.save.connect(self.save_account)
self.accountDlg.delete.connect(self.delete_account)
self.accountDlg.show()
def delete_account(self, index):
del self.accounts[index]
self.accounts_model.set(self.accounts)
def save_account(self, index, hostname, port, username, password, local_dir, remote_dir):
self.accounts[index].hostname = hostname
self.accounts[index].username = username
self.accounts[index].port = port
self.accounts[index].password = password
self.accounts[index].local_dir = local_dir
self.accounts[index].remote_dir = remote_dir
self.accounts_model.set(self.accounts)
self.savePrefs()
def setupMenu(self):
helpMenu = QMenu(self.tr("&Help"), self)
self.menuBar().addMenu(helpMenu)
helpMenu.addAction(self.tr("&About"), self.do_about)
def do_about(self):
self.about_win = KhtEditorAbout(self)
class ConfigDialog(QDialog):
wake = pyqtSignal(object)
serversChanged = pyqtSignal()
def __init__(self, *args, **kwargs):
QDialog.__init__(self, *args, **kwargs)
self.ui = Ui_Settings()
self.ui.setupUi(self)
self.autoUpdate = False
self.ui.newServer.clicked.connect(self.addServer)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, VENDOR, APP)
mac_re = QRegExp("([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}")
self.ui.macText.setValidator(QRegExpValidator(mac_re, self.ui.macText))
self.ui.aliasText.textChanged.connect(self.enableSave)
self.ui.portText.textChanged.connect(self.enableSave)
self.ui.macText.textChanged.connect(self.enableSave)
self.ui.macText.textChanged.connect(self.dropStyle)
self.ui.asBroadcastCheck.stateChanged.connect(self.enableSave)
self.ui.saveServer.clicked.connect(self.updateServer)
self.ui.resetServer.clicked.connect(self.resetServer)
self.ui.deleteServer.clicked.connect(self.deleteServer)
self.ui.wakeServer.clicked.connect(self.wakeServer)
self.serversModel = ServersModel()
self.ui.serversView.setModel(self.serversModel)
self.ui.serversView.selectionModel().selectionChanged.connect(self.serverChanged)
servers = self.settings.beginReadArray("servers")
for d in range(servers):
self.settings.setArrayIndex(d)
s = Server.fromSettings(self.settings, self.alias(d))
self.serversModel.append(s)
self.settings.endArray()
def dropStyle(self):
self.sender().setStyleSheet('color: auto')
@classmethod
def alias(cls, d):
return 'New server %d' % d
def addServer(self):
d = 1
while True:
alias = self.alias(d)
if not self.serversModel.contains(alias):
break
d += 1
alias = self.alias(d)
index = self.serversModel.append(Server(alias))
self.saveServers()
if index.isValid():
self.ui.serversView.setFocus()
sm = self.ui.serversView.selectionModel()
sm.clear()
sm.select(index, QItemSelectionModel.Rows|QItemSelectionModel.Select)
def serverSelected(self):
selected = [x for x in self.ui.serversView.selectionModel().selectedIndexes() if x.column() == 0 and x.isValid()]
if not selected:
return None
return selected[0]
def serverChanged(self, set, unset):
selection = self.serverSelected()
if not selection:
self.ui.aliasText.setText('')
self.ui.portText.setText('')
self.ui.macText.setText('')
self.ui.asBroadcastCheck.setChecked(False)
self.ui.groupBox.setEnabled(False)
self.ui.saveServer.setEnabled(False)
self.ui.resetServer.setEnabled(False)
self.ui.deleteServer.setEnabled(False)
self.ui.wakeServer.setEnabled(False)
return
self.ui.groupBox.setEnabled(True)
self.ui.saveServer.setEnabled(False)
self.ui.resetServer.setEnabled(False)
self.ui.deleteServer.setEnabled(True)
self.ui.wakeServer.setEnabled(True)
server = selection.internalPointer()
self.setServer(server)
def setServer(self, server):
self.autoUpdate = True
self.ui.aliasText.setText(server.alias)
self.ui.portText.setText('%d' % server.port)
self.ui.macText.setText(server.mac)
self.ui.asBroadcastCheck.setChecked(server.broadcast)
self.autoUpdate = False
def enableSave(self):
if not self.autoUpdate and self.serverSelected():
self.ui.saveServer.setEnabled(True)
self.ui.resetServer.setEnabled(True)
def deleteServer(self):
selection = self.serverSelected()
if not selection:
return
server = selection.internalPointer()
if QMessageBox.Yes != QMessageBox.question(self, 'Confirm action', 'Do you want to remove server "%s" from the list?' % server.alias, QMessageBox.Yes|QMessageBox.No):
return
self.ui.deleteServer.setEnabled(False)
self.ui.serversView.model().delete(selection)
self.saveServers()
def wakeServer(self):
selection = self.serverSelected()
if not selection:
return
server = selection.internalPointer()
self.wake.emit(server)
def updateServer(self):
selection = self.serverSelected()
if not selection:
return
validator = self.ui.macText.validator()
mac = self.ui.macText.text()
state, pos = validator.validate(mac, 0)
if state != QValidator.Acceptable:
self.ui.macText.setStyleSheet('color: red')
self.ui.macText.setFocus()
self.ui.macText.setCursorPosition(len(mac))
return
self.ui.saveServer.setEnabled(False)
self.ui.resetServer.setEnabled(False)
def updateServer(server):
server.alias = self.ui.aliasText.text()
server.port = int(self.ui.portText.text())
server.mac = mac
server.broadcast = bool(self.ui.asBroadcastCheck.isChecked())
self.ui.serversView.model().update(selection, updateServer)
self.saveServers()
def resetServer(self):
selection = self.serverSelected()
if not selection:
return
self.ui.saveServer.setEnabled(False)
self.ui.resetServer.setEnabled(False)
server = selection.internalPointer()
self.setServer(server)
def saveServers(self):
self.settings.beginWriteArray("servers")
model = self.ui.serversView.model()
for d in range(model.rowCount()):
self.settings.setArrayIndex(d)
server = model.index(d).internalPointer()
server.save(self.settings)
self.settings.endArray()
self.serversChanged.emit()
