def live_button(self):
"""
Action triggered when the 'live' button is pressed
"""
self.dockwidget.liveButton.setEnabled(False)
# if no layer do nothing
if not self.dockwidget.checkBoxCorrected.isChecked():
if not self.dockwidget.checkBoxDifference.isChecked():
if not self.dockwidget.checkBoxBrut.isChecked():
ErrorWindow("Erreur selection couche", "Veillez selectionner une couche avant de continuer",
"critical")
#enable live_button
self.dockwidget.liveButton.setEnabled(True)
return
# init core
if self.core is None:
# Get the current database selection (in the UI selector)
selected = self.dockwidget.databaseSelector.currentText()
if selected == "":
ErrorWindow("Erreur selection base de donnees",
"Veillez selectionner une base de donnees avant de valider",
"information")
# enable live_button
self.dockwidget.liveButton.setEnabled(True)
return
# Construct the @Core class (Main Class)
# The Class need the global information of the database
# The Class need to manipulate layers so a reference to the interface (iface) is required
self.core = Core(
self.database_connection.value(selected + '/host'),
self.database_connection.value(selected + '/port'),
self.database_connection.value(selected + '/username'),
self.database_connection.value(selected + '/password'),
self.database_connection.value(selected + '/database'),
self.iface
)
self.core.connect_init()
self.update_layer_list()
print("live -> stop")
# unbind live event
self.dockwidget.liveButton.clicked.disconnect(self.live_button)
# change text
self.dockwidget.liveButton.setText("Stop")
# bind stop event
self.dockwidget.liveButton.clicked.connect(self.stop_button)
# enable liveButton
self.dockwidget.liveButton.setEnabled(True)
# disable resetButton
self.dockwidget.resetButton.setEnabled(False)
def validate(self):
"""check with master list to ensure all keywords are valid"""
try:
with open(data_files._IMAGEKEYWORDS) as keys:
keywords = keys.readlines()
except IOError:
tkMessageBox.showwarning('Warning',
'Keywords reference not found!',
parent=self)
return
keywords = [x.strip() for x in keywords]
errors = []
for row in range(0, self.pt.rows):
for col in range(1, self.pt.cols):
val = str(self.pt.model.getValueAt(row, col))
if val != 'nan' and val != '' and val not in keywords:
errors.append('Invalid keyword for ' +
str(self.pt.model.getValueAt(row, 0)) +
' (Row ' + str(row + 1) + ', Keyword' +
str(col) + ', Value: ' + val + ')')
if errors:
ErrorWindow(self, errors)
else:
tkMessageBox.showinfo('Spreadsheet Validation',
'All keywords are valid.',
parent=self)
def Process(self, asset ):
# Construct defaults
self.Set_Defaults()
# Update the asset
self.asset_data = asset
self.sub_field_range[2] = len(self.asset_data.address_list)
self.sub_field_range[3] = len(self.asset_data.registered_scanners)
# Start loop
self.exit_window = False
while self.exit_window != True:
# Clear the screen
self.screen.clear()
# Print the header
self.Render_Header()
# Render the main window
self.Render_Main_Content()
# Print the footer
self.Render_Footer()
# Refresh
self.screen.addstr( curses.LINES-1, 0, 'option:')
self.screen.refresh()
# Get the input
c = self.screen.getch()
# If user wants to quit
if c == 27:
self.exit_window = True
return asset
# If the user wants to modify the current asset
if c == ord('m'):
if self.current_field == 2 and self.sub_fields[self.current_field] < len(self.asset_data.address_list):
# Modify
new_asset_address = AssetAddAddressSubWindow(self.screen).Process(mode=AddressWindowMode.MODIFY, address=self.asset_data.address_list[self.sub_fields[self.current_field]])
if new_asset_address is not None:
self.asset_data.address_list[self.sub_fields[self.current_field]] = new_asset_address
# If the user provides the enter key
elif c == curses.KEY_ENTER or c == 10:
# Check if the user requested to add an address
if self.current_field == 2 and self.sub_fields[self.current_field] == len(self.asset_data.address_list):
# Render the add address window
new_asset_address = AssetAddAddressSubWindow(self.screen).Process(mode=AddressWindowMode.ADD)
# Add the address
if new_asset_address is not None:
self.asset_data.address_list.append(new_asset_address)
self.sub_field_range[self.current_field] += 1
# Otherwise, add the asset
else:
# Make sure the network is valid
status_flag, error_msg = self.asset_data.Is_Valid(print_error_msg=True)
if status_flag is False:
# Render an error window
ErrorWindow().Process(self.screen, 'Invalid Asset.', error_msg)
else:
self.exit_window = True
# If the user provides arrow key, increment the cursor
elif c == ord('\t') or c == curses.KEY_DOWN:
self.Increment_Active_Field()
# If the user provides up arrow key, decrement the cursor
elif c == curses.KEY_UP:
self.Decrement_Active_Field()
# If entry is text, add to entry
else:
self.Process_Text( c )
# Write the asset
self.asset_data.Write_Asset_File()
# Return the updated llnms state
return self.asset_data
def Process(self, llnms_state):
# Clear the network data
self.network_data = Network(name='',
address_start='',
address_end='',
description='')
# Start loop
self.exit_window = False
while self.exit_window != True:
# Clear the screen
self.screen.clear()
# Print the header
self.Render_Header()
# Render the main window
self.Render_Main_Content()
# Print the footer
self.Render_Footer()
# Refresh
self.screen.addstr(curses.LINES - 1, 0, 'input :')
self.screen.refresh()
# Get the input
c = self.screen.getch()
# If user wants to quit
if c == 27:
self.exit_window = True
# If the user provides the enter key
elif c == curses.KEY_ENTER or c == 10:
# Make sure the network is valid
status, error_msg = self.network_data.Is_Valid(
print_error_msg=True)
if status is False:
# Render an error window
ErrorWindow().Process(self.screen, 'Invalid Network.',
error_msg)
else:
llnms_state.Add_Network(self.network_data)
self.exit_window = True
# If the user provides arrow key, switch
elif c == ord('\t') or c == curses.KEY_DOWN:
self.current_field = (self.current_field + 1) % len(
self.cursors)
# If the user provides up
elif c == curses.KEY_UP:
self.current_field = (self.current_field - 1) % len(
self.cursors)
# If entry is text, add to entry
else:
self.Process_Text(c)
# Return the updated llnms state
return llnms_state
from ConfigWindow import ConfigWindow
from MainWindow import MainWindow
from ErrorWindow import ErrorWindow
from Sensor import Sensor
import config
if __name__ == "__main__":
try:
app = QtWidgets.QApplication([])
config_window = ConfigWindow()
setup = config_window.get_setup()
if setup:
stream, batch_size, reuse_size = setup
assert batch_size < config.HISTORY
sensor = Sensor(stream, batch_size, reuse_size)
main_window = MainWindow(sensor)
main_window.show()
sys.exit(app.exec_())
except Exception as e:
error_window = ErrorWindow(str(e), traceback.format_exc())
# TODO: no error being thrown when bad wifi config is given
class Controller:
def __init__(self):
self.setup_window = SetupWindow()
self.setup_window.switch_window.connect(self.show_parse_window)
self.setup_window.show()
def show_parse_window(self):
try:
self.parse_window = ParseWindow(self.setup_window.savegame_list,
self.setup_window.playertags)
self.parse_window.switch_back.connect(self.back_to_setup)
self.parse_window.switch_edit_nations.connect(
self.show_edit_nations)
self.parse_window.switch_configure_nations.connect(
self.show_configure_nations)
self.parse_window.switch_main_window.connect(self.show_main_window)
self.parse_window.show()
self.setup_window.close()
except AttributeError as err:
self.setup_window.show()
self.setup_window.status.showMessage(
"Error:{}. Select two Savegames".format(err))
def back_to_setup(self):
self.setup_window.savegame_list = [[], []]
self.setup_window.line1.setText("")
self.setup_window.line2.setText("")
self.setup_window.show()
self.parse_window.close()
def show_edit_nations(self, b):
self.edit_nations_window = EditNations(b, self.parse_window.playertags,
self.parse_window.tag_list)
self.edit_nations_window.set_playertags.connect(self.set_playertags)
self.edit_nations_window.show()
def set_playertags(self):
self.parse_window.playertags_table.clear()
self.parse_window.playertags_table.setRowCount(
len(self.parse_window.playertags))
for i in range(len(self.parse_window.playertags)):
item = Widgets.QTableWidgetItem()
item.setData(Core.Qt.DisplayRole, self.parse_window.playertags[i])
item.setFlags(Core.Qt.ItemIsEnabled)
self.parse_window.playertags_table.setItem(i, 0, item)
self.parse_window.playertags_table.setHorizontalHeaderLabels(
["Player-Tags"])
if self.parse_window.playertags:
self.parse_window.remove_all_button.setEnabled(True)
self.parse_window.remove_button.setEnabled(True)
else:
self.parse_window.remove_all_button.setEnabled(False)
self.parse_window.remove_button.setEnabled(False)
def show_configure_nations(self):
self.configure_window = ConfigureNationFormations(
self.parse_window.savegame_list,
self.setup_window.old_nations_list,
self.setup_window.new_nations_list,
self.parse_window.formable_nations_dict)
self.configure_window.set_nation_formations.connect(
self.set_nation_formations)
self.configure_window.show()
def set_nation_formations(self, formable_nations_dict):
self.parse_window.formable_nations_dict = formable_nations_dict
for label in self.parse_window.label_list:
label.clear()
for (key, value), label in zip(
self.parse_window.formable_nations_dict.items(),
self.parse_window.label_list):
label.setText("{0} {1} {2}".format(value, chr(10230), key))
def show_main_window(self):
self.main_window = MainWindow(self.parse_window.savegame_list,\
self.parse_window.formable_nations_dict, self.parse_window.playertags)
self.main_window.main.switch_table_window.connect(
self.show_table_window)
self.main_window.main.switch_province_table_window.connect(
self.show_province_table_window)
self.main_window.main.back_to_parse_window.connect(
self.back_to_parse_window)
self.main_window.main.switch_overview_window.connect(
self.show_overview_window)
self.main_window.main.switch_monarch_table_window.connect(
self.show_monarch_table_window)
self.main_window.main.switch_error_window.connect(
self.show_error_window)
self.main_window.main.switch_nation_profile.connect(
self.show_nation_profile)
self.main_window.show()
self.parse_window.close()
def show_table_window(self, data, title):
self.table_window = TableWindow(self.parse_window.savegame_list, data,
title)
self.table_window.switch_nation_selecter.connect(
self.show_nation_selecter)
self.table_window.switch_commander_selecter.connect(
self.show_commander_selecter)
self.table_window.switch_war_selecter.connect(self.show_war_selecter)
self.table_window.switch_to_individual_war.connect(
self.show_individual_war)
self.table_window.show()
def show_province_table_window(self, data, title):
self.province_table_window = ProvinceTableWindow(
self.parse_window.savegame_list, data, title)
self.province_table_window.switch_province_filter.connect(
self.show_province_filter)
self.province_table_window.switch_nation_selecter.connect(
self.show_nation_selecter)
self.province_table_window.show()
def show_nation_selecter(self, data):
self.nation_select_window = NationSelecter(
data, self.parse_window.savegame_list)
self.nation_select_window.update_table.connect(self.update_table)
self.nation_select_window.show()
def show_commander_selecter(self):
self.commander_select_window = CommanderSelecter(
self.table_window.data, self.parse_window.savegame_list)
self.commander_select_window.update_table.connect(self.update_table)
self.commander_select_window.show()
def show_war_selecter(self):
self.war_select_window = WarSelecter(self.table_window.data,
self.parse_window.savegame_list)
self.war_select_window.update_table.connect(self.update_table)
self.war_select_window.show()
def show_province_filter(self, number, data):
self.province_filter = ProvinceFilter(number, data)
self.province_filter.update_table.connect(self.update_table)
self.province_filter.show()
def show_individual_war(self, war):
self.individual_war_window = IndividualWarTable(
self.parse_window.savegame_list[1].war_dict[war], war,
self.parse_window.savegame_list)
self.individual_war_window.back_to_table_window.connect(
self.back_to_table_window)
self.individual_war_window.show()
self.table_window.close()
def back_to_table_window(self):
self.table_window.show()
self.individual_war_window.close()
def update_table(self, category, data):
if category == "army":
self.table_window.armyTable(data)
if category == "navy":
self.table_window.navyTable(data)
if category == "province":
self.province_table_window.provinceTable(data)
def show_overview_window(self, title, categories, colormap_options,
header_labels, data):
self.overview_window = OverviewTable(self.parse_window.savegame_list,
self.parse_window.playertags,
title, categories,
colormap_options, header_labels,
data)
self.overview_window.show()
def show_monarch_table_window(self, title, data, labels):
self.monarch_table_window = MonarchTableWindow(
title, data, labels, self.parse_window.savegame_list[1].color_dict)
self.monarch_table_window.show()
def show_error_window(self, e):
self.error_window = ErrorWindow(e)
self.error_window.show()
def show_nation_profile(self, tag):
self.nation_profile = ProfileWindow(
tag, self.setup_window.localisation_dict)
def back_to_parse_window(self):
self.parse_window.show()
self.main_window.close()
def show_error_window(self, e):
self.error_window = ErrorWindow(e)
self.error_window.show()
def __init__(self, host, port, username, password, database, ui):
"""
Constructor the @Core class. It initialized everything necessary for the layer manipulation.
:param host: The database hostname
:param port: The database port
:param username: The database username
:param password: The database password
:param database: The database name
:param ui: The Iface (UI) reference (required to manipulate layers)
"""
# List of the layers that will be drawn on the map when not empty
self.layer_names = []
# List of the layers drawn on the map
self.layers = {}
# Notification key to detect change in DB
# (see: https://www.postgresql.org/docs/9.1/static/sql-notify.html)
self.notify_key = 'siren_key'
# URI of the database. This information is required for the database connection in Layers
self.uri = QgsDataSourceURI()
if host is None:
ErrorWindow(
"Erreur hote",
"Veuillez indiquer l'hote dans les parametres de connexion",
"critical")
return
if port is None:
ErrorWindow(
"Erreur port",
"Veuillez indiquer le port dans les parametres de connexion",
"critical")
return
if username is None:
ErrorWindow(
"Erreur username",
"Veuillez indiquer le nom d'utilisation dans les parametres de connexion",
"critical")
return
if password is None:
ErrorWindow(
"Erreur password",
"Veuillez indiquer le mot de passe dans les parametres de connexion",
"critical")
return
if database is None:
ErrorWindow(
"Erreur database",
"Veuillez indiquer la base de donnees dans les parametres de connexion",
"critical")
return
# Database information
self.host = host
self.port = port
self.username = username
self.password = password
self.database = database
self.ui = ui
# Set information for the layer URI
self.uri.setConnection(host, port, database, username, password)