def retrieveAllStoredServerInfo(self):
"""
Retrieves a list of ThreddsServerInfo objects stored in the
underlying settings object for this application.
Uses the Group definition "self.ThreddsServerGroup" to know
under which 'namespace' are these elements stored. This allows
us to store other configuration settings under other 'namespaces'
using the same QSettings object.
:returns A list of objects which contain information about
the thredds servers previously stored in the settings
object.
:rtype [ThreddsServerInfoObject]
"""
serverList = []
settings = QSettings()
settings.beginGroup(self.ThreddsServerGroup)
for element in settings.childKeys():
srv = settings.value(element, None)
if srv is not None:
serverList.append(srv);
settings.endGroup()
return serverList
class Preferences(PrefsBA):
prefsSaved = pyqtSignal()
def __init__(self, parent, autoload=0):
self.parent = parent
PrefsBA.__init__(self, parent)
self.settings = QSettings()
if autoload:
self.load()
def load(self):
for preference in self.settings.childKeys():
try:
setting = self.settings.value(preference)
if preference == "Font":
self.parent.setfont(setting.toPyObject())
if preference == "Match Font":
self.parent.setMatchFont(setting.toPyObject())
if preference == "Email Server":
self.emailServerEdit.setText(setting.toPyObject())
if preference == "Recent Files Count":
self.recentFilesSpinBox.setValue(int(setting.toPyObject()))
except Exception, e:
print "Loading of configuration key", preference, "failed."
self.settings.remove(preference)
class Preferences(PrefsBA):
prefsSaved = pyqtSignal()
def __init__(self, parent, autoload=0):
self.parent = parent
PrefsBA.__init__(self, parent)
self.settings = QSettings()
if autoload:
self.load()
def load(self):
for preference in self.settings.childKeys():
try:
setting = self.settings.value(preference)
if preference == 'Font':
self.parent.setfont(setting.toPyObject())
if preference == 'Match Font':
self.parent.setMatchFont(setting.toPyObject())
if preference == 'Email Server':
self.emailServerEdit.setText(setting.toPyObject())
if preference == 'Recent Files Count':
self.recentFilesSpinBox.setValue(int(setting.toPyObject()))
except Exception, e:
print "Loading of configuration key", preference, "failed."
self.settings.remove(preference)
def retrieveAllStoredServerInfo(self):
"""
Retrieves a list of ThreddsServerInfo objects stored in the
underlying settings object for this application.
Uses the Group definition "self.ThreddsServerGroup" to know
under which 'namespace' are these elements stored. This allows
us to store other configuration settings under other 'namespaces'
using the same QSettings object.
:returns A list of objects which contain information about
the thredds servers previously stored in the settings
object.
:rtype [ThreddsServerInfoObject]
"""
serverList = []
settings = QSettings()
settings.beginGroup(self.ThreddsServerGroup)
for element in settings.childKeys():
srv = settings.value(element, None)
if srv is not None:
serverList.append(srv)
settings.endGroup()
return serverList
def retrieveAllStoredServerInfo(self):
"""Retrieves a list of ThreddsServerInfo objects stored in the
underlying settings object for this application.
Uses the Group definition "self.ThreddsServerGroup" to know
under which 'namespace' are these elements stored. This allows
us to store other configuration settings under other 'namespaces'
using the same QSettings object.
:returns A list of objects which contain information about the thredds
servers previously stored in the settings object.
:rtype [ThreddsServerInfoObject]
"""
serverList = []
settings = QSettings()
settings.beginGroup(self.ThreddsServerGroup)
for key in settings.childKeys():
ret = settings.value(key)
if type(ret) in [ str, unicode ]:
name, url = key, ret
else:
try:
name, url = ret
except:
continue
serverList.append(ThreddsServerInfoObject(name, url));
settings.endGroup()
return serverList
class settings:
def __init__(self):
self.s = QSettings()
# database settings
self.conName = self.s.value("vmm/conname", "")
self.dbhost = self.s.value("vmm/dbhost", "")
self.dbport = self.s.value("vmm/dbport", "5432")
self.database = self.s.value("vmm/database", "")
self.dbuser = self.s.value("vmm/dbuser", "")
self.dbpassw = self.s.value("vmm/dbpassw", r"")
# layer
self.schema = self.s.value("vmm/schema", r"")
self.polyLayer = self.s.value("vmm/polyLayer", r"")
self.polyLayerGeom = self.s.value("vmm/polyLayerGeom", r"")
self.polyLayerName = self.s.value("vmm/polyLayerName", r"")
self._pgSettings()
def _getProxySettings(self):
self.proxyEnabled = self.proxyHost = self.proxyPort = self.proxyUser = self.proxyPassword = None
self.proxyUrl = ""
proxyEnabled = self.s.value("proxy/proxyEnabled", "")
if proxyEnabled == 1 or self.proxyEnabled == "true":
self.proxyEnabled = True
self.proxyHost = self.s.value("proxy/proxyHost", "")
self.proxyPort = self.s.value("proxy/proxyPort", "")
self.proxyUser = self.s.value("proxy/proxyUser", "")
self.proxyPassword = self.s.value("proxy/proxyPassword", "")
self.proxyUrl = "http://"
if self.proxyUser and self.proxyPassword:
self.proxyUrl += self.proxyUser + ":" + self.proxyPassword + "@"
self.proxyUrl += self.proxyHost + ":" + self.proxyPort
def _pgSettings(self):
self.s.beginGroup("PostgreSQL/connections")
cons = self.s.childGroups()
self.connections = {}
for con in cons:
self.s.beginGroup(con)
self.connections[con] = {n: self.s.value(n) for n in self.s.childKeys()}
self.s.endGroup()
self.s.endGroup()
def saveSettings(self):
# database settings
self.s.setValue("vmm/conname", self.conName)
self.s.setValue("vmm/dbhost", self.dbhost)
self.s.setValue("vmm/database", self.database)
self.s.setValue("vmm/dbport", self.dbport)
self.s.setValue("vmm/dbuser", self.dbuser)
self.s.setValue("vmm/dbpassw", self.dbpassw)
# layer
self.s.setValue("vmm/schema", self.schema)
self.s.setValue("vmm/polyLayer", self.polyLayer)
self.s.setValue("vmm/polyLayerGeom", self.polyLayerGeom)
self.s.setValue("vmm/polyLayerName", self.polyLayerName)
def removeServerCookies(self):
settings = QSettings()
settings.beginGroup(self.cookieSettings)
cookie_keys = settings.childKeys()
if cookie_keys is not None:
for key in cookie_keys:
settings.remove(key)
settings.endGroup()
def removeServerCookies(self):
settings = QSettings()
settings.beginGroup(self.cookieSettings)
cookie_keys = settings.childKeys()
if cookie_keys is not None:
for key in cookie_keys:
settings.remove(key)
settings.endGroup()
def cookiesForUrl(self, url):
settings = QSettings(self.m_cookiesFile, QSettings.IniFormat)
cookieList = []
settings.beginGroup(url.host())
for cname in settings.childKeys():
cookieList.append(QNetworkCookie(cname, settings.value(cname)))
return cookieList
def getServerCookies(self):
cookieList = []
settings = QSettings()
settings.beginGroup(self.cookieSettings)
childKeys = settings.childKeys()
if childKeys is not None:
for key in childKeys:
cookieList.append(key + "=" + settings.value(key))
settings.endGroup()
return ";".join(cookieList)
def cookiesForUrl(self, url):
settings = QSettings(self.m_cookieFile, QSettings.IniFormat)
cookieList = []
settings.beginGroup(url.host())
for cname in settings.childKeys():
cookieList.append(QNetworkCookie(cname, settings.value(cname)))
return cookieList
def getServerCookies(self):
cookieList = []
settings = QSettings()
settings.beginGroup(self.cookieSettings)
childKeys = settings.childKeys()
if childKeys is not None:
for key in childKeys:
cookieList.append(key + "=" + settings.value(key))
settings.endGroup()
return ";".join(cookieList)
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 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 getSetting(self, key):
"""
Get one setting from the in-memory store and if not present then the settings file
:return:
"""
value = None
if key in _SETTINGS and 'value' in _SETTINGS[key]:
value = _SETTINGS[key]['value']
else:
s = QSettings()
s.beginGroup(BASE)
if key in s.childKeys():
value = s.value(key)
_SETTINGS[key]['value'] = value
s.endGroup()
return value
def __init__(self):
super(SettingsBorg, self).__init__()
if not self._initdone:
print "Init Settings"
s = QSettings()
# Do a sanity check and reset anything that looks fishy
for key in _SETTINGS.iterkeys():
s.beginGroup(BASE)
if key not in s.childKeys():
self.resetDefault(key)
else:
val = self.getSetting(key)
if len(val) == 0 or val is None:
self.resetDefault(key)
s.endGroup()
# Must be the last thing we do in init
self._initdone = True
def is_chrome_installed():
"""
Checks the system registry to assert if Chrome has been installed and
the corresponding installation path.
:return: Returns a tuple containing the installation status and if True
the installation path.
:rtype: tuple(status,inst_path)
"""
status, inst_path = False, ''
default_key = '.'
chrome_reg_key = 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\' \
'CurrentVersion\\App Paths\\chrome.exe'
settings = QSettings(chrome_reg_key, QSettings.NativeFormat)
if len(settings.childKeys()) > 0:
if settings.contains(default_key):
inst_path = settings.value(default_key)
status = True
return status, inst_path
def loadSettings(self, currentKey, namesGroup):
# don't mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default", type(""))
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
block = self.scheme.blockSignals(True)
self.scheme.clear()
self.scheme.addItem(_("Default"), "default")
lst = [(s.value(key, key, type("")), key) for key in s.childKeys()]
for name, key in sorted(lst, key=lambda f: f[0].lower()):
self.scheme.addItem(name, key)
# find out index
index = self.scheme.findData(cur)
self.disableDefault(cur == 'default')
self.scheme.setCurrentIndex(index)
self.scheme.blockSignals(block)
self.currentChanged.emit()
def loadSettings(self, currentKey, namesGroup):
# dont mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default", type(""))
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
self.scheme.clear()
self.scheme.addItem(_("Default"), "default")
lst = [(s.value(key, key, type("")), key) for key in s.childKeys()]
for name, key in sorted(lst, key=lambda f: f[0].lower()):
self.scheme.addItem(name, key)
block = self.scheme.blockSignals(True)
# find out index
index = self.scheme.findData(cur)
self.disableDefault(cur == 'default')
self.scheme.setCurrentIndex(index)
self.scheme.blockSignals(block)
self.currentChanged.emit()
def loadSettings(self, currentKey, namesGroup):
# dont mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default")
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
self._schemes = ["default"]
self._schemeNames = [_("Default")]
for key in s.childKeys():
self._schemes.append(key)
self._schemeNames.append(s.value(key, key))
block = self.scheme.blockSignals(True)
self.scheme.clear()
self.scheme.addItems(self._schemeNames)
# find out index
index = self._schemes.index(cur) if cur in self._schemes else 0
self.remove.setEnabled(bool(index))
self.scheme.setCurrentIndex(index)
self.scheme.blockSignals(block)
self.currentChanged.emit()
def retrieveAllStoredServerInfo(self):
"""Retrieves a list of ThreddsServerInfo objects stored in the
underlying settings object for this application.
Uses the Group definition "self.ThreddsServerGroup" to know
under which 'namespace' are these elements stored. This allows
us to store other configuration settings under other 'namespaces'
using the same QSettings object.
:returns A list of objects which contain information about the thredds
servers previously stored in the settings object.
:rtype [ThreddsServerInfoObject]
"""
print "retrieve info"
serverList = []
settings = QSettings('Threddsserver.ini', 'list_server')
settings.beginGroup(self.ThreddsServerGroup)
for key in settings.childKeys():
ret = str(settings.value(key).toPyObject())
print ret
print type(ret)
if type(ret) in [str, unicode]:
name, url = key, ret
print name, url
else:
try:
name, url = ret
except:
continue
serverList.append(ThreddsServerInfoObject(name, url))
settings.endGroup()
return serverList
class ini_setting:
"""
class for managing .ini file and project defaults
"""
release_mode = False
def __init__(self, file_name):
"""
constructor: read setting values into a QSetting object
Args:
file_name: ini file name
"""
self.file_name = file_name
self.error_msg = ""
self.groups_with_values = {} # all values read
self.groups = {} # group names and key names
self.config = None
if self.config is None and os.path.isfile(self.file_name):
try:
self.config = QSettings(self.file_name, QSettings.IniFormat)
self.build_setting_map()
print("Read project settings from " + self.file_name)
except Exception as exINI:
self.config = None
self.error_msg = "Reading Error" + ":\n" + str(exINI)
else:
if file_name:
self.create_ini_file(file_name)
def create_ini_file(self, file_name):
"""
Specify .ini file path after instantiation
if setting is not yet instantiated:
a new setting is instantiated
if the new setting has no key:
a new ini file is created
Args:
file_name: the full path to an ini file
Returns: True if successful; False if failed
"""
if os.path.isfile(self.file_name): return False
if self.config is None:
try:
self.config = QSettings(file_name, QSettings.IniFormat)
if len(self.config.allKeys()) == 0:
# this is a brand new ini file
self.config.setValue("Model/Name", "")
self.config.sync()
print("created ini file: " + file_name)
else:
print("Read settings from ini file: " + file_name)
self.file_name = file_name
return True
except Exception as exINI:
self.config = None
self.error_msg = "Reading Error" + ":\n" + str(exINI)
return False
def get_setting_value(self, group, key):
"""
Get the value of a ini setting, assuming all settings are grouped
Args:
group: the string name of a group or section
key: the string name of a key
Returns:
a list of two elements, first being the value, second being the value type
"""
rval = [None, None]
if len(self.groups) == 0:
return rval
if not self.groups.has_key(group):
return rval
self.config.beginGroup(group)
qvar = self.config.value(key)
if qvar is None:
self.config.endGroup()
return rval
str_val = unicode(qvar)
if len(str_val) > 0:
tval, tval_is_good = ParseData.intTryParse(str_val)
if tval_is_good:
rval[0] = tval
rval[1] = "integer"
self.config.endGroup()
return rval
tval, tval_is_good = ParseData.floatTryParse(str_val)
if tval_is_good:
rval[0] = tval
rval[1] = "float"
self.config.endGroup()
return rval
rval[0] = str_val
rval[1] = "string"
self.config.endGroup()
return rval
elif str_val == "":
rval[0] = ""
rval[1] = "string"
else:
str_list = qvar.toStringList().join(",")
if len(str_list) > 0:
rval[0] = str_list.strip(",").split(",")
rval[1] = "stringlist"
self.config.endGroup()
return rval
self.config.endGroup()
return rval
def build_setting_map(self):
"""
Build a setting group-key-value mapping dictionary as below:
self.groups_with_values
[group_name] -> [key_name] -> [value, value_type]
Also create group dictionary keyed on group name, pointing to its list of keys
so we can get setting values on a as needed basis
self.groups
[group_name] -> [key names]
"""
self.groups.clear()
self.groups_with_values.clear()
for group in self.config.childGroups():
self.config.beginGroup(group)
self.groups_with_values[group] = {}
self.groups[group] = []
for key in self.config.childKeys():
self.groups[group].append(key)
val, vtype = self.get_setting_value(group, key)
self.groups_with_values[group][key] = val
# print group + "::" + key + "::" + self.config.value(key).toString()
self.config.endGroup()
def read_ini_file_cp(self):
self.config.read(self.file_name)
for section in self.config.sections():
dict1 = self.config_section_map(section)
pass
pass
def config_section_map(self, section):
dict1 = {}
for option in self.config.options(section):
try:
dict1[option] = self.config.get(section, option)
if dict1[option] == -1:
print "skip: %s" % option
pass
except:
print "exception on %s!" % option
dict1[option] = None
return dict1
def checkServerCookies(self):
settings = QSettings()
settings.beginGroup(self.cookieSettings)
childKeys = settings.childKeys()
return True if childKeys is not None and len(childKeys) > 0 else False
def checkServerCookies(self):
settings = QSettings()
settings.beginGroup(self.cookieSettings)
childKeys = settings.childKeys()
return True if childKeys is not None and len(childKeys) > 0 else False
