def check_changes(self):
"""Check if the user has changed any settings which are not saved."""
if self.chk_reload.isChecked():
no_reload_value = "Y"
else:
no_reload_value = "N"
# Retrieve from system
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
# Check all entries against UI elements.
settings.beginReadArray("script_assistant")
settings.setArrayIndex(self.cmb_config.currentIndex())
if self.cmb_config.lineEdit().text() == settings.value("configuration") and \
self.lne_script.text() == settings.value("script_folder") and \
self.lne_test.text() == settings.value("test_folder") and \
self.lne_test_data.text() == settings.value("test_data_folder") and \
no_reload_value == settings.value("no_reload"):
self.btn_save.setEnabled(False)
self.setWindowTitle("Script Assistant Configuration")
else:
self.btn_save.setEnabled(True)
self.setWindowTitle("Script Assistant Configuration*")
settings.endArray()
def restore_settings():
global main_widget
global name, email, place
global ROS_PKGS, ROS_MSGS, ROS_SRVS
settings = QSettings('semCo', 'ROSLab IDE')
name = str(settings.value('name', 'Frodo'))
email = str(settings.value('email', '*****@*****.**'))
place = str(settings.value('place', 'Middle Earth'))
# get message packages
size = settings.beginReadArray('msg_packages')
for i in range(size):
settings.setArrayIndex(i)
name = settings.value('name', '')
ROS_MSGS.append(name)
settings.endArray()
if len(ROS_MSGS):
print('found {0} packages containing messages'.format(len(ROS_MSGS)))
# get service packages
size = settings.beginReadArray('srv_packages')
for i in range(size):
settings.setArrayIndex(i)
name = settings.value('name', '')
ROS_SRVS.append(name)
settings.endArray()
if len(ROS_SRVS):
print('found {0} packages containing services'.format(len(ROS_SRVS)))
if not (len(ROS_MSGS) or len(ROS_SRVS)):
QMessageBox.information(main_widget, 'ROSLab IDE', 'Could not load message & service packages. Will scan now!')
scan_ros_distro()
def fetch_profiles():
profiles = []
settings = QSettings()
size = settings.beginReadArray('database_profiles')
if size == 0:
return profiles
for index in range(size):
settings.setArrayIndex(index)
info = {}
profilename = decode_setting(
settings.value('profilename', QVariant('')).toString())
if not profilename:
continue # well we should not really be doing anything
info['profilename'] = profilename
info['dialect'] = decode_setting(
settings.value('dialect', QVariant('')).toString())
info['host'] = decode_setting(
settings.value('host', QVariant('')).toString())
info['port'] = decode_setting(
settings.value('port', QVariant('')).toString())
info['database'] = decode_setting(
settings.value('database', QVariant('')).toString())
info['user'] = decode_setting(
settings.value('user', QVariant('')).toString())
info['pass'] = decode_setting(
settings.value('pass', QVariant('')).toString())
profiles.append(info)
settings.endArray()
return profiles
def fetch_profiles():
profiles = []
settings = QSettings()
size = settings.beginReadArray("database_profiles")
if size == 0:
return profiles
for index in range(size):
settings.setArrayIndex(index)
info = {}
profilename = decode_setting(settings.value("profilename", QVariant("")).toString())
if not profilename:
continue # well we should not really be doing anything
info["profilename"] = profilename
info["dialect"] = decode_setting(settings.value("dialect", QVariant("")).toString())
info["host"] = decode_setting(settings.value("host", QVariant("")).toString())
info["port"] = decode_setting(settings.value("port", QVariant("")).toString())
info["database"] = decode_setting(settings.value("database", QVariant("")).toString())
info["user"] = decode_setting(settings.value("user", QVariant("")).toString())
info["pass"] = decode_setting(settings.value("pass", QVariant("")).toString())
profiles.append(info)
settings.endArray()
return profiles
def show_configuration(self):
"""Show saved configuration in settings dialog."""
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
settings.beginReadArray("script_assistant")
settings.setArrayIndex(self.cmb_config.currentIndex())
self.lne_script.setText(settings.value("script_folder"))
self.lne_test.setText(settings.value("test_folder"))
self.lne_test_data.setText(settings.value("test_data_folder"))
if settings.value("no_reload") == "Y":
self.chk_reload.setChecked(True)
elif settings.value("no_reload") == "N":
self.chk_reload.setChecked(False)
settings.endArray()
def _loadSettings(self):
settings = QSettings()
x = settings.beginReadArray(self._group)
if x > 0:
for i in range(0, x):
settings.setArrayIndex(i)
clause = FilterClause.fromSettings(settings)
self._clauses.append(clause)
self.status = 'loaded'
settings.endArray()
def _loadSettings(self):
settings = QSettings()
x = settings.beginReadArray(self._group)
if x > 0:
for i in range(0, x):
settings.setArrayIndex(i)
clause = FilterClause.fromSettings(settings)
self._clauses.append(clause)
self.status = 'loaded'
settings.endArray()
def read(self, iniFile=None):
if iniFile is not None:
s = QSettings(iniFile, QSettings.IniFormat)
else:
s = QSettings()
properties = dict()
properties['Mobiles'] = dict()
s.beginGroup('PosiView')
count = s.beginReadArray('Mobiles')
for i in range(count):
s.setArrayIndex(i)
mobile = dict()
for k in s.childKeys():
mobile[k] = self.convertToBestType(s.value(k))
properties['Mobiles'][mobile['Name']] = mobile
s.endArray()
properties['Provider'] = dict()
count = s.beginReadArray('DataProvider')
for i in range(count):
s.setArrayIndex(i)
provider = dict()
for k in s.childKeys():
provider[k] = self.convertToBestType(s.value(k))
properties['Provider'][provider['Name']] = provider
s.endArray()
properties['Mission'] = dict()
properties['Mission']['cruise'] = s.value('Mission/Cruise', 'CruiseXX')
properties['Mission']['dive'] = s.value('Mission/Dive', 'DiveX')
properties['Mission']['station'] = s.value('Mission/Station', '#xxx')
properties['RecorderPath'] = s.value('Recorder/Path', environ['HOME'])
properties['AutoRecord'] = s.value('Recorder/AutoRecord',
False,
type=bool)
properties['NotifyDuration'] = s.value('Misc/NotifyDuration',
0,
type=int)
properties['ShowUtcClock'] = s.value('Misc/ShowUtcClock',
False,
type=bool)
s.endGroup()
return properties
def loadConnections(self):
settings = QSettings(self)
velkost = settings.beginReadArray("connections")
for i in range(velkost):
settings.setArrayIndex(i)
local = settings.value("local").toBool();
path = settings.value("path").toString();
host = settings.value("host").toString();
port = settings.value("port").toInt()[0];
password = settings.value("password").toString()
self.addConnection(local, path, host, port, password)
settings.endArray()
def readSettings(self):
settings = QSettings()
settings.beginGroup("MainWindow")
self.resize(settings.value("Size", QVariant(QSize(965, 655))).toSize())
self.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("BrowsePanel")
self.browsePanel.setVisible(settings.value("Visible", QVariant(True)).toBool())
self.browsePanel.setFloating(settings.value("Floating", QVariant(False)).toBool())
self.browsePanel.resize(settings.value("Size", QVariant(QSize(250, 655))).toSize())
self.browsePanel.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("FilterPanel")
self.filterPanel.setVisible(settings.value("Visible", QVariant(True)).toBool())
self.filterPanel.setFloating(settings.value("Floating", QVariant(False)).toBool())
self.filterPanel.resize(settings.value("Size", QVariant(QSize(270, 655))).toSize())
self.filterPanel.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("DataView")
self.dataView.setFixedWidthFont(settings.value("FixedWidthFont", QVariant(False)).toBool())
settings.endGroup()
settings.beginGroup("FindDialog")
d = self.dataView.findDialog
d.setVisible(settings.value("Visible", QVariant(False)).toBool())
d.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
# Note: QVariant.toInt returns a tuple with the result of the conversion
# and a boolean for the successful conversion
d.setFindFlags(settings.value("Flags", QVariant(0)).toInt()[0])
d.setWrappedSearch(settings.value("WrappedSearch", QVariant(True)).toBool())
settings.endGroup()
self.iovUTCCheckBox.setChecked(settings.value("IOVs/UTC", QVariant(True)).toBool())
size = settings.beginReadArray("Recent")
for i in range(size):
settings.setArrayIndex(i)
conn = settings.value("ConnString").toString()
action = QAction(self)
action.setText(conn)
QObject.connect(action, SIGNAL("triggered()"), self.openRecentDatabase)
self.menuRecent.addAction(action)
settings.endArray()
settings.beginGroup("Misc")
self._showWelcome = settings.value("ShowWelcome", QVariant(True)).toBool()
self._externalEditor = str(settings.value("ExternalEditor", QVariant("emacs")).toString())
settings.endGroup()
def restoreSettings(self):
s = QSettings()
n = s.beginReadArray('EMailList')
print "n=", n
for i in range(n):
s.setArrayIndex(i)
checked = s.value('Checked', Qt.Checked, type=Qt.CheckState)
address = s.value('EMail', '', type=QString)
print i, checked, address
item = QListWidgetItem(address)
item.setCheckState(checked)
self.emailListWidget.insertItem(0, item)
s.endArray()
def run(self):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
filename='/home/user/.khtsync.log',
filemode='w')
settings = QSettings("Khertan Software", "KhtSync")
logging.debug('Setting loaded')
while True:
try:
#Re read the settings
settings.sync()
logging.debug('Setting synced')
#Verify the default interval
if not settings.contains('refresh_interval'):
refresh_interval = 600
else:
refresh_interval = int(settings.value('refresh_interval'))*60
if refresh_interval<600:
refresh_interval = 600
logging.debug('refresh interval loaded')
nb_accounts = settings.beginReadArray('accounts')
logging.info('Found %s account to sync' % (str(nb_accounts),))
for index in range(nb_accounts):
settings.setArrayIndex(index)
try:
# logging.exception('Connecting to %s',str(sync.hostname))
sync = khtsync.Sync(hostname=settings.value('hostname'), \
port=int(settings.value('port')), \
username=settings.value('username'), \
password=settings.value('password'), \
local_dir=settings.value('local_dir'), \
remote_dir=settings.value('remote_dir'))
logging.info('Connecting to %s',str(sync.hostname))
# logging.debug('test')
sync.connect()
sync.sync()
sync.close()
except:
logging.exception('Error occur while syncing with %s',str(sync.hostname))
settings.endArray()
logging.debug('Finished loop')
except Error,err:
logging.exception(str(err))
logging.debug(str(err))
time.sleep(refresh_interval)
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 read(self, iniFile=None):
if iniFile is not None:
s = QSettings(iniFile, QSettings.IniFormat)
else:
s = QSettings()
properties = dict()
properties['Mobiles'] = dict()
s.beginGroup('PosiView')
count = s.beginReadArray('Mobiles')
for i in range(count):
s.setArrayIndex(i)
mobile = dict()
for k in s.childKeys():
mobile[k] = self.convertToBestType(s.value(k))
properties['Mobiles'][mobile['Name']] = mobile
s.endArray()
properties['Provider'] = dict()
count = s.beginReadArray('DataProvider')
for i in range(count):
s.setArrayIndex(i)
provider = dict()
for k in s.childKeys():
provider[k] = self.convertToBestType(s.value(k))
properties['Provider'][provider['Name']] = provider
s.endArray()
properties['Mission'] = dict()
properties['Mission']['cruise'] = s.value('Mission/Cruise', 'CruiseXX')
properties['Mission']['dive'] = s.value('Mission/Dive', 'DiveX')
properties['Mission']['station'] = s.value('Mission/Station', '#xxx')
properties['RecorderPath'] = s.value('Recorder/Path', environ['HOME'])
properties['AutoRecord'] = s.value('Recorder/AutoRecord', False, type=bool)
properties['NotifyDuration'] = s.value('Misc/NotifyDuration', 0, type=int)
properties['ShowUtcClock'] = s.value('Misc/ShowUtcClock', False, type=bool)
s.endGroup()
return properties
def restoreSettings(self):
s = QSettings()
# geometry = s.value('geometry', QByteArray(), type=QByteArray)
# self.restoreGeometry(geometry)
rows = s.beginReadArray('currentTable')
for i in range(rows)[::-1]:
s.setArrayIndex(i)
enabled = s.value('enabled', True, type=bool)
rampRate = s.value('rampRate', 10, type=float)
target = s.value('target', 0.2, type=float)
holdTime = s.value('holdTime', 60, type=float)
self.addRowClicked(enabled, rampRate, target, holdTime)
s.endArray()
def load(self):
settings = QSettings()
cnt = settings.beginReadArray("RecentFiles")
# PyQt bug: cnt is always 0, workaround with "None" test below
i = -1
while True:
i += 1
settings.setArrayIndex(i)
try:
s = settings.value("Filename").toPyObject()
if s == None:
break
self.__recent_files.append(str(s))
except Exception, e:
print "Loading of recent file entry", i, "failed."
if self.debug: print e
settings.remove("Filename")
def infos():
"""Returns all configured LilyPondInfo for the different used LilyPond versions."""
global _infos
if _infos is None:
s = QSettings()
_infos = []
for i in range(s.beginReadArray("lilypondinfo")):
s.setArrayIndex(i)
info = LilyPondInfo.read(s)
if info:
_infos.append(info)
s.endArray()
if not _infos:
info = default()
if info.abscommand():
_infos.append(info)
app.aboutToQuit.connect(saveinfos)
return _infos
def infos():
"""Returns all configured LilyPondInfo for the different used LilyPond versions."""
global _infos
if _infos is None:
s = QSettings()
_infos = []
for i in range(s.beginReadArray("lilypondinfo")):
s.setArrayIndex(i)
info = LilyPondInfo.read(s)
if info:
_infos.append(info)
s.endArray()
if not _infos:
info = default()
if info.abscommand():
_infos.append(info)
app.aboutToQuit.connect(saveinfos)
return _infos
def loadSettings(self, s=None):
'''Load table contents from QSettings'''
if s is None:
s = QSettings()
name = self.objectName()
if len(name) == 0:
raise Exception(
'Cannot load settings without objectName property set.')
rowCount = s.beginReadArray(name)
rowCount = min(self.rowCount(), rowCount)
rowCount = self.rowCount()
print rowCount
for row in range(rowCount):
s.setArrayIndex(row)
for columnName in self.columnNames:
w = self.cellWidgetByName(row, columnName)
restoreWidgetFromSettings(s, w, columnName)
s.endArray()
def load_configuration():
"""Load configuration."""
settings = QSettings(
os.path.join(QgsApplication.qgisSettingsDirPath(),
"scriptassistant", "config.ini"),
QSettings.IniFormat,
)
size = settings.beginReadArray("script_assistant")
config = {}
for i in xrange(size):
settings.setArrayIndex(i)
config[i] = {
"configuration": settings.value("configuration"),
"script_folder": settings.value("script_folder"),
"test_data_folder": settings.value("test_data_folder"),
"test_folder": settings.value("test_folder"),
"no_reload": settings.value("no_reload"),
}
settings.endArray()
return config
def restoreSettings(self):
s = QSettings(OrganizationName, ApplicationName)
self.populateDevices()
for w in self.settingsWidgets:
restoreWidgetFromSettings(s, w)
geometry = s.value('geometry', QByteArray(), type=QByteArray)
self.restoreGeometry(geometry)
state = s.value('splitter1State', QByteArray(), type=QByteArray)
self.splitter1.restoreState(state)
state = s.value('splitter2State', QByteArray(), type=QByteArray)
self.splitter2.restoreState(state)
rows = s.beginReadArray('frequencyTable')
for row in range(rows):
s.setArrayIndex(row)
enabled = s.value('active', True, type=bool)
f = s.value('f', 10*(3**row), type=float)
A = s.value('A', 0.1, type=float)
phase = s.value('phase', 0, type=float)
bw = s.value('bw', 5, type=float)
order = s.value('order', 8, type=int)
self.addTableRow(row, enabled, f, A, phase, bw, order)
s.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()
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, VENDOR, APP)
self.setup = ConfigDialog(None, Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
self.setup.setModal(True)
centerOnScreen(self.setup)
self.setup.wake.connect(self.wake)
self.setup.serversChanged.connect(self.updateMenu)
self.menuServers = []
self.trayIcon = QSystemTrayIcon(QIcon("res/power.png"), self)
self.trayIcon.activated.connect(self.activated)
menu = QMenu()
self.populateMenuFromSettings(menu)
menu.addSeparator()
self.setupAction = menu.addAction(QIcon('res/setup.png'), "Configure")
self.setupAction.triggered.connect(self.setup.show)
menu.addSeparator()
exitAction = menu.addAction("Exit")
exitAction.triggered.connect(self.close)
self.trayIcon.setContextMenu(menu)
self.trayIcon.setToolTip("Wake on LAN")
self.trayIcon.show()
servers = self.settings.beginReadArray("servers")
self.settings.endArray()
if not servers:
self.setup.show()
def populateMenuFromSettings(self, menu):
"""
:type menu: QMenu
"""
actions = menu.actions()
before = actions[0] if actions else None
title = QWidgetAction(menu)
label = QLabel("Hosts")
font = label.font()
px = font.pointSize()
font.setBold(True)
font.setPointSize(px * 1.5)
label.setFont(font)
label.setMargin(4)
label.setIndent(10)
# label.setStyleSheet("font-weight: bold; margin: 4px 2px; border-bottom: 2px solid black")
title.setDefaultWidget(label)
menu.insertAction(before, title)
self.menuServers.append(title)
servers = self.settings.beginReadArray("servers")
for d in range(servers):
self.settings.setArrayIndex(d)
server = Server.fromSettings(self.settings)
action = QAction(QIcon("res/server.png"), server.alias, menu)
menu.insertAction(before, action)
action.setData(server)
action.triggered.connect(self.wakeFromMenu)
self.menuServers.append(action)
self.settings.endArray()
def activated(self, reason):
if reason == QSystemTrayIcon.DoubleClick:
self.setup()
elif reason == QSystemTrayIcon.Trigger:
menu = QMenu()
self.populateMenuFromSettings(menu)
menu.exec_(QCursor.pos())
def updateMenu(self):
menu = self.trayIcon.contextMenu()
for action in self.menuServers:
action.setData(None)
menu.removeAction(action)
self.populateMenuFromSettings(menu)
def wakeFromMenu(self):
action = self.sender()
server = action.data().toPyObject()
self.wake(server)
def wake(self, server):
if QMessageBox.Yes == QMessageBox.question(self, "Wake on LAN", "Wake %s?" % server.alias, QMessageBox.Yes|QMessageBox.No):
magic = '\xFF' * 6
bits = str(server.mac).split(':')
machex = ''.join([struct.pack('B', (int(x, 16))) for x in bits])
magic += machex * 16
sock = socket(type=SOCK_DGRAM)
if server.broadcast:
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.sendto(magic, ('<broadcast>', server.port))
sock.close()
self.trayIcon.showMessage("Wake on LAN", "Magic packet was sent to %s" % server.alias, msecs=3000)
def close(self):
QApplication.quit()
