def get_row(info):
replacement = '0.0.0'
is_red_brick = isinstance(info, infos.BrickREDInfo)
if is_red_brick or info.url_part == 'wifi_v2':
replacement = "Querying..."
elif info.type == "extension":
replacement = ""
fw_version = infos.get_version_string(info.firmware_version_installed,
replace_unknown=replacement,
is_red_brick=is_red_brick)
uid = info.uid if info.type != "extension" else ''
row = [QStandardItem(info.name),
QStandardItem(uid),
QStandardItem(info.position.title()),
QStandardItem(fw_version)]
updateable = info.firmware_version_installed != (0, 0, 0) and info.firmware_version_installed < info.firmware_version_latest
if is_red_brick:
old_updateable = updateable
for binding in info.bindings_infos:
updateable |= binding.firmware_version_installed != (0, 0, 0) \
and binding.firmware_version_installed < binding.firmware_version_latest
updateable |= info.brickv_info.firmware_version_installed != (0, 0, 0) \
and info.brickv_info.firmware_version_installed < info.brickv_info.firmware_version_latest \
and not info.firmware_version_installed < (1, 14, 0) # Hide Brickv update if image is too old.
# There are bindings/brickv updates but there is no image update
red_brick_binding_update_only = not old_updateable and updateable
else:
red_brick_binding_update_only = False
if updateable:
self.tree_view_model.setHorizontalHeaderLabels(self.tree_view_model_labels + ['Update'])
row.append(QStandardItem(
infos.get_version_string(info.firmware_version_latest, is_red_brick=is_red_brick) + ("+" if red_brick_binding_update_only else "")))
self.tab_widget.tabBar().setTabButton(0, QTabBar.RightSide, self.update_tab_button)
self.update_tab_button.show()
for item in row:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if updateable:
item.setData(QBrush(QColor(255, 160, 55)), Qt.BackgroundRole)
return row
def create_and_append_row(info, parent):
try:
metric_names = info.plugin.get_health_metric_names()
except:
metric_names = []
fw_version = QStandardItem(
get_version_string(info.firmware_version_installed,
replace_unknown='?'))
if info.firmware_version_installed < info.firmware_version_latest:
font = fw_version.font()
font.setBold(True)
fw_version.setFont(font)
row = [
QStandardItem(info.name),
QStandardItem(info.uid),
QStandardItem(info.position.title()), fw_version,
QStandardItem(str(self.metric_errors.get(info.uid, 0)))
]
for metric_name in metric_names:
try:
i = self.dynamic_column_names.index(metric_name)
except:
self.dynamic_column_names.append(metric_name)
i = len(self.dynamic_column_names) - 1
self.tree_view_model.setHorizontalHeaderItem(
column_offset + i, QStandardItem(metric_name))
while len(row) <= column_offset + i:
row.append(QStandardItem())
item = row[column_offset + i]
old_timestamp, old_value = self.old_values.get(
info.uid, {}).get(metric_name, (None, None))
item.setText(str(old_value if old_value != None else '-'))
if old_timestamp != None and old_timestamp + SETTLE_DURATION >= time.monotonic(
):
font = item.font()
if not font.bold():
font.setBold(True)
item.setFont(font)
for item in row:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
parent.appendRow(row)
return row
def device_info_changed(self, uid):
if uid != self.device_info.uid:
return
if self.device_info.tab_window is None:
return
if self.device_info.firmware_version_installed < self.device_info.firmware_version_latest:
self.show_update()
else:
self.hide_update()
self.hardware_version = self.device_info.hardware_version
self.firmware_version = self.device_info.firmware_version_installed
self.label_version.setText(get_version_string(self.firmware_version))
if self.button_parent is not None:
self.button_parent.setText(self.device_info.connected_uid)
self.button_parent.clicked.connect(lambda: get_main_window().show_plugin(self.device_info.connected_uid))
if self.label_position is not None:
self.label_position.setText(self.device_info.position.title())
def refresh_updates_clicked(self):
if self.tab_widget.currentIndex() != 0:
self.refresh_updates_pending = True
return
self.update_button_refresh.setDisabled(True)
self.refresh_updates_pending = False
url_part_proto1_map = {
# 'name': 'url_part'
'Ambient Light Bricklet': 'ambient_light',
'Analog In Bricklet': 'analog_in',
'Analog Out Bricklet': 'analog_out',
'Barometer Bricklet': 'barometer',
'Current12 Bricklet': 'current12',
'Current25 Bricklet': 'current25',
'Distance IR Bricklet': 'distance_ir',
'Dual Relay Bricklet': 'dual_relay',
'GPS Bricklet': 'gps',
'Humidity Bricklet': 'humidity',
'Industrial Digital In 4 Bricklet': 'industrial_digital_in_4',
'Industrial Digital Out 4 Bricklet': 'industrial_digital_out_4',
'Industrial Quad Relay Bricklet': 'industrial_quad_relay',
'IO-16 Bricklet': 'io16',
'IO-4 Bricklet': 'io4',
'Joystick Bricklet': 'joystick',
'LCD 16x2 Bricklet': 'lcd_16x2',
'LCD 20x4 Bricklet': 'lcd_20x4_v11',
'Linear Poti Bricklet': 'linear_poti',
'Piezo Buzzer Bricklet': 'piezo_buzzer',
'Rotary Poti Bricklet': 'rotary_poti',
'Temperature Bricklet': 'temperature',
'Temperature-IR Bricklet': 'temperature_ir',
'Voltage Bricklet': 'voltage',
'Voltage/Current Bricklet': 'voltage_current',
}
progress = self.create_progress_bar('Discovering')
okay = True
try:
urllib2.urlopen(FIRMWARE_URL, timeout=10).read()
self.no_connection_label.hide()
except urllib2.URLError:
okay = False
progress.cancel()
self.no_connection_label.show()
return
if okay:
self.refresh_latest_version_info(progress)
def get_color_for_device(device):
if device.firmware_version_installed >= device.firmware_version_latest:
return None, False
if device.firmware_version_installed[0] <= 1:
return QBrush(Qt.red), True
return QBrush(QColor(255, 160, 55)), True
try:
infos.get_info(infos.UID_BRICKV).firmware_version_latest = self.tool_infos['brickv'].firmware_version_latest
except:
infos.get_info(infos.UID_BRICKV).firmware_version_latest = (0, 0, 0)
for device_info in infos.get_device_infos():
if device_info.type == 'brick':
try:
device_info.firmware_version_latest = self.firmware_infos[device_info.url_part].firmware_version_latest
except:
device_info.firmware_version_latest = (0, 0, 0)
elif device_info.type == 'bricklet':
try:
device_info.firmware_version_latest = self.plugin_infos[device_info.url_part].firmware_version_latest
except:
device_info.firmware_version_latest = (0, 0, 0)
progress.cancel()
self.update_tree_view_model.clear()
self.update_tree_view_model.setHorizontalHeaderLabels(self.update_tree_view_model_labels)
is_update = False
protocol1_errors = set()
items = []
for device_info in infos.get_infos():
if device_info.type == 'brick':
parent = [QStandardItem(device_info.name),
QStandardItem(device_info.uid),
QStandardItem(get_version_string(device_info.firmware_version_installed)),
QStandardItem(get_version_string(device_info.firmware_version_latest))]
color, update = get_color_for_device(device_info)
if update:
is_update = True
for item in parent:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
item.setData(color, Qt.BackgroundRole)
parent[0].setData(device_info.uid, Qt.UserRole)
items.append(parent)
for port in device_info.bricklets:
if not device_info.bricklets[port] or device_info.bricklets[port].protocol_version == 1:
try:
protv, fw, name = device_info.plugin.device.get_protocol1_bricklet_name(port)
except:
protocol1_errors.add(device_info.uid)
child = [QStandardItem(port.upper() + ': Protocol 1.0 Bricklet with Error'),
QStandardItem(''),
QStandardItem(''),
QStandardItem('')]
for item in child:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
item.setData(QBrush(Qt.magenta), Qt.BackgroundRole)
parent[0].appendRow(child)
continue
if protv == 1:
# Hack for LCD 20x4 Bricklet (name is not set early enough in firmware)
if fw == (1, 1, 1) and name == '':
name = 'LCD 20x4 Bricklet'
bricklet_info = infos.BrickletInfo()
bricklet_info.protocol_version = 1
bricklet_info.name = name
bricklet_info.position = port
bricklet_info.firmware_version_installed = tuple(fw)
device_info.bricklets[port] = bricklet_info
for key in url_part_proto1_map:
if key in device_info.bricklets[port].name:
bricklet_info.url_part = url_part_proto1_map[key]
break
try:
bricklet_info.firmware_version_latest = self.plugin_infos[bricklet_info.url_part].firmware_version_latest
except KeyError:
pass
if device_info.bricklets[port]:
child = [QStandardItem(port.upper() + ': ' + device_info.bricklets[port].name),
QStandardItem(device_info.bricklets[port].uid),
QStandardItem(get_version_string(device_info.bricklets[port].firmware_version_installed)),
QStandardItem(get_version_string(device_info.bricklets[port].firmware_version_latest))]
color, update = get_color_for_device(device_info.bricklets[port])
if update:
is_update = True
for item in child:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
item.setData(color, Qt.BackgroundRole)
parent[0].appendRow(child)
elif device_info.type == 'tool' and 'Brick Viewer' in device_info.name:
parent = [QStandardItem(device_info.name),
QStandardItem(''),
QStandardItem(get_version_string(device_info.firmware_version_installed)),
QStandardItem(get_version_string(device_info.firmware_version_latest))]
color, update = get_color_for_device(device_info)
if update:
self.update_tool_label.show()
else:
self.update_tool_label.hide()
for item in parent:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
item.setData(color, Qt.BackgroundRole)
items.append(parent)
t = 0
if len(protocol1_errors) > 0:
# if there were protocol1 errors give the enumerate callback a
# chance to update the infos to have correct information to filter
# out false-positive protocol1 errors that were detected due to
# fast USB unplug
t = 200
QTimer.singleShot(t, lambda: self.refresh_updates_clicked_second_step(is_update, items, protocol1_errors))
def __init__(self, wifi2_firmware_version, parent):
QWidget.__init__(self)
self.setupUi(self)
self.parent = parent
self.master = parent.master
self.wifi2_status = None
if parent.firmware_version < (2, 4, 0):
# This should not be possible
return
self.wifi2_firmware_version = wifi2_firmware_version
self.wifi_update_firmware_button.setIcon(
QIcon(load_pixmap('update-icon-normal.png')))
self.wifi_update_firmware_button.clicked.connect(
lambda: get_main_window().show_extension_update(parent.device_info.
uid))
self.wifi_update_firmware_button.hide()
self.wifi_firmware_version_label.setText(
get_version_string(
wifi2_firmware_version,
replace_unknown='Waiting for WIFI Extension 2.0 FW Version...')
)
self.general_group = [
self.wifi_port_label, self.wifi_port,
self.wifi_websocket_port_label, self.wifi_websocket_port,
self.wifi_website_port_label, self.wifi_website_port,
self.wifi_disable_web_interface, self.wifi_phy_mode_label,
self.wifi_phy_mode, self.wifi_use_auth, self.wifi_secret_label,
self.wifi_secret, self.wifi_show_characters
]
self.authentication_group = [
self.wifi_secret_label, self.wifi_secret, self.wifi_show_characters
]
self.client_ip_group = [
self.wifi_client_ip_label, self.wifi_client_sub_label,
self.wifi_client_gw_label, self.wifi_client_ip4,
self.wifi_client_ip3, self.wifi_client_ip2, self.wifi_client_ip1,
self.wifi_client_sub4, self.wifi_client_sub3,
self.wifi_client_sub2, self.wifi_client_sub1, self.wifi_client_gw4,
self.wifi_client_gw3, self.wifi_client_gw2, self.wifi_client_gw1,
self.wifi_client_dot1, self.wifi_client_dot2,
self.wifi_client_dot3, self.wifi_client_dot4,
self.wifi_client_dot5, self.wifi_client_dot6,
self.wifi_client_dot7, self.wifi_client_dot8, self.wifi_client_dot9
]
self.client_bssid_group = [
self.wifi_client_bssid_label, self.wifi_client_bssid6,
self.wifi_client_bssid5, self.wifi_client_bssid4,
self.wifi_client_bssid3, self.wifi_client_bssid2,
self.wifi_client_bssid1, self.wifi_client_bssid_dot1,
self.wifi_client_bssid_dot2, self.wifi_client_bssid_dot3,
self.wifi_client_bssid_dot4, self.wifi_client_bssid_dot5
]
self.client_mac_group = [
self.wifi_client_mac_label, self.wifi_client_mac6,
self.wifi_client_mac5, self.wifi_client_mac4,
self.wifi_client_mac3, self.wifi_client_mac2,
self.wifi_client_mac1, self.wifi_client_mac_dot1,
self.wifi_client_mac_dot2, self.wifi_client_mac_dot3,
self.wifi_client_mac_dot4, self.wifi_client_mac_dot5
]
self.client_enc_group = [
self.wifi_client_password_label, self.wifi_client_change_password,
self.wifi_client_password, self.wifi_client_password_show
]
self.ap_ip_group = [
self.wifi_ap_ip_label, self.wifi_ap_sub_label,
self.wifi_ap_gw_label, self.wifi_ap_ip4, self.wifi_ap_ip3,
self.wifi_ap_ip2, self.wifi_ap_ip1, self.wifi_ap_sub4,
self.wifi_ap_sub3, self.wifi_ap_sub2, self.wifi_ap_sub1,
self.wifi_ap_gw4, self.wifi_ap_gw3, self.wifi_ap_gw2,
self.wifi_ap_gw1, self.wifi_ap_dot1, self.wifi_ap_dot2,
self.wifi_ap_dot3, self.wifi_ap_dot4, self.wifi_ap_dot5,
self.wifi_ap_dot6, self.wifi_ap_dot7, self.wifi_ap_dot8,
self.wifi_ap_dot9
]
self.ap_mac_group = [
self.wifi_ap_mac_label, self.wifi_ap_mac6, self.wifi_ap_mac5,
self.wifi_ap_mac4, self.wifi_ap_mac3, self.wifi_ap_mac2,
self.wifi_ap_mac1, self.wifi_ap_mac_dot1, self.wifi_ap_mac_dot2,
self.wifi_ap_mac_dot3, self.wifi_ap_mac_dot4, self.wifi_ap_mac_dot5
]
self.ap_enc_group = [
self.wifi_ap_password_label, self.wifi_ap_change_password,
self.wifi_ap_password, self.wifi_ap_password_show
]
self.mesh_router_enc_group = [
self.wifi_mesh_router_password_label,
self.wifi_mesh_router_change_password,
self.wifi_mesh_router_password, self.wifi_mesh_router_password_show
]
self.mesh_root_static_ip_group = [
self.wifi_mesh_root_ip_label, self.wifi_mesh_root_sub_label,
self.wifi_mesh_root_gw_label, self.wifi_mesh_root_ip1,
self.wifi_mesh_root_ip2, self.wifi_mesh_root_ip3,
self.wifi_mesh_root_ip4, self.wifi_mesh_root_sub1,
self.wifi_mesh_root_sub2, self.wifi_mesh_root_sub3,
self.wifi_mesh_root_sub4, self.wifi_mesh_root_gw1,
self.wifi_mesh_root_gw2, self.wifi_mesh_root_gw3,
self.wifi_mesh_root_gw4, self.wifi_mesh_dot1, self.wifi_mesh_dot2,
self.wifi_mesh_dot3, self.wifi_mesh_dot4, self.wifi_mesh_dot5,
self.wifi_mesh_dot6, self.wifi_mesh_dot7, self.wifi_mesh_dot8,
self.wifi_mesh_dot9
]
self.mesh_router_bssid_group = [
self.wifi_mesh_router_bssid_label, self.wifi_mesh_router_bssid1,
self.wifi_mesh_router_bssid2, self.wifi_mesh_router_bssid3,
self.wifi_mesh_router_bssid4, self.wifi_mesh_router_bssid5,
self.wifi_mesh_router_bssid6, self.wifi_mesh_colon1,
self.wifi_mesh_colon2, self.wifi_mesh_colon3,
self.wifi_mesh_colon4, self.wifi_mesh_colon5
]
# Enable/disable web interface
self.wifi_disable_web_interface.stateChanged.connect(
self.wifi_disable_web_interface_state_changed)
# Passwords
self.wifi_secret_show_state_changed(Qt.Unchecked)
self.wifi_client_show_state_changed(Qt.Unchecked)
self.wifi_mesh_router_password_show_state_change(Qt.Unchecked)
self.wifi_ap_password_show_state_changed(Qt.Unchecked)
self.wifi_show_characters.stateChanged.connect(
self.wifi_secret_show_state_changed)
self.wifi_client_password_show.stateChanged.connect(
self.wifi_client_show_state_changed)
self.wifi_ap_password_show.stateChanged.connect(
self.wifi_ap_password_show_state_changed)
self.wifi_mesh_router_password_show.stateChanged.connect(
self.wifi_mesh_router_password_show_state_change)
self.wifi_client_change_password.stateChanged.connect(
self.wifi_client_change_password_changed)
self.wifi_ap_change_password.stateChanged.connect(
self.wifi_ap_change_password_changed)
self.wifi_mesh_router_change_password.stateChanged.connect(
self.wifi_mesh_router_change_password_changed)
# Use passwords
self.wifi_client_encryption_changed(1)
self.wifi_ap_encryption_changed(3)
self.wifi_mesh_router_encryption_changed(1)
self.wifi_use_auth_state_changed(Qt.Unchecked)
self.wifi_mesh_router_encryption_changed(0)
self.wifi_client_encryption.currentIndexChanged.connect(
self.wifi_client_encryption_changed)
self.wifi_ap_encryption.currentIndexChanged.connect(
self.wifi_ap_encryption_changed)
self.wifi_use_auth.stateChanged.connect(
self.wifi_use_auth_state_changed)
self.wifi_mesh_router_encryption.currentIndexChanged.connect(
self.wifi_mesh_router_encryption_changed)
# MACs
self.wifi_client_use_bssid_state_changed(Qt.Unchecked)
self.wifi_client_use_mac_state_changed(Qt.Unchecked)
self.wifi_ap_use_mac_state_changed(Qt.Unchecked)
self.wifi_client_use_bssid.stateChanged.connect(
self.wifi_client_use_bssid_state_changed)
self.wifi_client_use_mac.stateChanged.connect(
self.wifi_client_use_mac_state_changed)
self.wifi_ap_use_mac.stateChanged.connect(
self.wifi_ap_use_mac_state_changed)
self.wifi_mesh_use_router_bssid_state_changed(Qt.Unchecked)
self.wifi_mesh_router_use_bssid.stateChanged.connect(
self.wifi_mesh_use_router_bssid_state_changed)
# IP Configuration
self.wifi_client_ip_configuration_changed(0)
self.wifi_ap_ip_configuration_changed(0)
self.wifi_mesh_root_ip_configuration_changed(0)
self.wifi_client_ip_configuration.currentIndexChanged.connect(
self.wifi_client_ip_configuration_changed)
self.wifi_ap_ip_configuration.currentIndexChanged.connect(
self.wifi_ap_ip_configuration_changed)
self.wifi_mesh_root_ip_configuration.currentIndexChanged.connect(
self.wifi_mesh_root_ip_configuration_changed)
# Mode
self.wifi_mode_changed(0)
self.wifi_mode.currentIndexChanged.connect(self.wifi_mode_changed)
# Save/Status
self.wifi_save.clicked.connect(self.save_clicked)
self.wifi_show_status.clicked.connect(self.show_status_clicked)
self.client_enable = False
self.ap_enable = False
self.mesh_enable = False
# Check if the master brick and WIFI extension 2 firmware versions
# support mesh networking feature
if self.wifi2_firmware_version >= (
2, 1, 0) and self.parent.firmware_version >= (2, 4, 2):
self.wifi_mode.addItem('Mesh')
self.label_mesh_hint.hide()
def create_tab_window(self, device_info, connected_uid, position):
tab_window = TabWindow(self.tab_widget, device_info.name, self.untab)
tab_window._info = device_info
tab_window.set_callback_on_tab(lambda index:
self.ipcon.get_connection_state() == IPConnection.CONNECTION_STATE_PENDING and \
self.tab_widget.setTabEnabled(index, False))
layout = QVBoxLayout(tab_window)
info_bar = QHBoxLayout()
# uid
info_bar.addWidget(QLabel('UID:'))
label = QLabel('{0}'.format(device_info.uid))
label.setTextInteractionFlags(Qt.TextSelectableByMouse |
Qt.TextSelectableByKeyboard)
info_bar.addWidget(label)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# connected uid
if connected_uid != '0':
info_bar.addWidget(QLabel('Connected to:'))
button = QToolButton()
button.setText(connected_uid)
button.clicked.connect(lambda: self.show_plugin(connected_uid))
info_bar.addWidget(button)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# position
info_bar.addWidget(QLabel('Position:'))
info_bar.addWidget(QLabel('{0}'.format(position.upper())))
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# firmware version
label_version_name = QLabel('Version:')
label_version = QLabel('...')
if not device_info.plugin.has_custom_version(label_version_name, label_version):
label_version_name.setText('FW Version:')
label_version.setText(infos.get_version_string(device_info.plugin.firmware_version))
info_bar.addWidget(label_version_name)
info_bar.addWidget(label_version)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# timeouts
info_bar.addWidget(QLabel('Timeouts:'))
label_timeouts = QLabel('0')
info_bar.addWidget(label_timeouts)
layout.addLayout(info_bar)
# actions
actions = device_info.plugin.get_actions()
if actions != None:
if type(actions) == QAction:
button = QPushButton(actions.text())
button.clicked.connect(actions.trigger)
else:
button = QToolButton()
button.setText(actions[0])
button.setPopupMode(QToolButton.InstantPopup)
button.setToolButtonStyle(Qt.ToolButtonTextOnly)
button.setArrowType(Qt.DownArrow)
button.setAutoRaise(True)
menu = QMenu(actions[0])
button.setMenu(menu)
for action in actions[1]:
menu.addAction(action)
info_bar.addSpacerItem(QSpacerItem(40, 20, QSizePolicy.Expanding))
info_bar.addWidget(button)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
device_info.plugin.label_timeouts = label_timeouts
device_info.plugin.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(line)
layout.addWidget(device_info.plugin)
return tab_window
def create_tab_window(self, device_info, ipcon):
tab_window = TabWindow(self.tab_widget, device_info.name, self.untab)
tab_window._info = device_info
tab_window.add_callback_on_tab(lambda index:
self.ipcon.get_connection_state() == IPConnection.CONNECTION_STATE_PENDING and \
self.tab_widget.setTabEnabled(index, False),
'main_window_disable_tab_if_connection_pending')
layout = QVBoxLayout(tab_window)
info_bars = [QHBoxLayout(), QHBoxLayout()]
# uid
info_bars[0].addWidget(QLabel('UID:'))
label = QLabel('{0}'.format(device_info.uid))
label.setTextInteractionFlags(Qt.TextSelectableByMouse
| Qt.TextSelectableByKeyboard)
info_bars[0].addWidget(label)
info_bars[0].addSpacerItem(QSpacerItem(20, 1, QSizePolicy.Preferred))
# firmware version
label_version_name = QLabel('Version:')
label_version = QLabel('Querying...')
button_update = QPushButton(QIcon(self.button_update_pixmap_normal),
'Update')
button_update.installEventFilter(self)
if isinstance(device_info, BrickREDInfo):
button_update.clicked.connect(self.show_red_brick_update)
elif device_info.flashable_like_bricklet:
button_update.clicked.connect(lambda: self.show_bricklet_update(
device_info.connected_uid, device_info.position))
elif device_info.kind == 'brick':
button_update.clicked.connect(
lambda: self.show_brick_update(device_info.url_part))
if not device_info.plugin.has_custom_version(label_version_name,
label_version):
label_version_name.setText('FW Version:')
label_version.setText(
get_version_string(device_info.plugin.firmware_version))
info_bars[0].addWidget(label_version_name)
info_bars[0].addWidget(label_version)
info_bars[0].addWidget(button_update)
button_update.hide()
tab_window.button_update = button_update
info_bars[0].addSpacerItem(QSpacerItem(20, 1, QSizePolicy.Preferred))
# timeouts
info_bars[0].addWidget(QLabel('Timeouts:'))
label_timeouts = QLabel('0')
info_bars[0].addWidget(label_timeouts)
info_bars[0].addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# connected uid
if device_info.connected_uid != '0':
info_bars[1].addWidget(QLabel('Connected to:'))
button = QToolButton()
button.setText(device_info.connected_uid)
button.clicked.connect(
lambda: self.show_plugin(device_info.connected_uid))
device_info.plugin.button_parent = button
info_bars[1].addWidget(button)
info_bars[1].addSpacerItem(
QSpacerItem(20, 1, QSizePolicy.Preferred))
# position
info_bars[1].addWidget(QLabel('Position:'))
label_position = QLabel('{0}'.format(device_info.position.title()))
device_info.plugin.label_position = label_position
info_bars[1].addWidget(label_position)
info_bars[1].addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# configs
configs = device_info.plugin.get_configs()
def config_changed(combobox):
i = combobox.currentIndex()
if i < 0:
return
combobox.itemData(i).trigger()
if len(configs) > 0:
for cfg in configs:
if cfg[1] != None:
combobox = QComboBox()
for i, item in enumerate(cfg[2]):
combobox.addItem(item.text(), item)
item.triggered.connect(
functools.partial(combobox.setCurrentIndex, i))
combobox.currentIndexChanged.connect(
functools.partial(config_changed, combobox))
info_bars[cfg[0]].addWidget(QLabel(cfg[1]))
info_bars[cfg[0]].addWidget(combobox)
elif len(cfg[2]) > 0:
checkbox = QCheckBox(cfg[2][0].text())
cfg[2][0].toggled.connect(checkbox.setChecked)
checkbox.toggled.connect(cfg[2][0].setChecked)
info_bars[cfg[0]].addWidget(checkbox)
# actions
actions = device_info.plugin.get_actions()
if len(actions) > 0:
for action in actions:
if action[1] != None:
button = QPushButton(action[1])
menu = QMenu()
for item in action[2]:
menu.addAction(item)
button.setMenu(menu)
elif len(action[2]) > 0:
button = QPushButton(action[2][0].text())
button.clicked.connect(action[2][0].trigger)
info_bars[action[0]].addWidget(button)
def more_clicked(button, info_bar):
visible = button.text().replace(
'&', '') == 'More' # remove &s, they mark the buttons hotkey
if visible:
button.setText('Less')
else:
button.setText('More')
for i in range(info_bar.count()):
widget = info_bar.itemAt(i).widget()
if widget != None:
widget.setVisible(visible)
more_button = QPushButton('More')
more_button.clicked.connect(
lambda: more_clicked(more_button, info_bars[1]))
info_bars[0].addWidget(more_button)
for i in range(info_bars[1].count()):
widget = info_bars[1].itemAt(i).widget()
if widget != None:
widget.hide()
layout.addLayout(info_bars[0])
layout.addLayout(info_bars[1])
line = QFrame()
line.setObjectName("MainWindow_line")
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
device_info.plugin.label_timeouts = label_timeouts
device_info.plugin.label_version = label_version
device_info.plugin.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(line)
if device_info.plugin.has_comcu:
device_info.plugin.widget_bootloader = COMCUBootloader(
ipcon, device_info)
device_info.plugin.widget_bootloader.hide()
layout.addWidget(device_info.plugin.widget_bootloader)
layout.addWidget(device_info.plugin, 1)
return tab_window
def get_row(info):
replacement = '0.0.0'
is_red_brick = isinstance(info, BrickREDInfo)
if is_red_brick or info.url_part == 'wifi_v2':
replacement = "Querying..."
elif info.kind == "extension":
replacement = ""
fw_version = get_version_string(info.firmware_version_installed,
replace_unknown=replacement,
is_red_brick=is_red_brick)
uid = info.uid if info.kind != "extension" else ''
row = [
QStandardItem(info.name),
QStandardItem(uid),
QStandardItem(info.position.title()),
QStandardItem(fw_version)
]
updateable = info.firmware_version_installed != (
0, 0, 0
) and info.firmware_version_installed < info.firmware_version_latest
if is_red_brick:
old_updateable = updateable
for binding in info.bindings_infos:
updateable |= binding.firmware_version_installed != (0, 0, 0) \
and binding.firmware_version_installed < binding.firmware_version_latest
updateable |= info.brickv_info.firmware_version_installed != (0, 0, 0) \
and info.brickv_info.firmware_version_installed < info.brickv_info.firmware_version_latest \
and not info.firmware_version_installed < (1, 14, 0) # Hide Brickv update if image is too old.
# There are bindings/brickv updates but there is no image update
red_brick_binding_update_only = not old_updateable and updateable
else:
red_brick_binding_update_only = False
if updateable:
self.tree_view_model.setHorizontalHeaderLabels(
self.tree_view_model_labels + ['Update'])
row.append(
QStandardItem(
get_version_string(info.firmware_version_latest,
is_red_brick=is_red_brick) +
("+" if red_brick_binding_update_only else "")))
self.tab_widget.tabBar().setTabButton(0, QTabBar.RightSide,
self.update_tab_button)
self.update_tab_button.show()
for item in row:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if updateable:
item.setData(QBrush(QColor(255, 160, 55)),
Qt.BackgroundRole)
return row
def create_tab_window(self, device_info, ipcon):
tab_window = TabWindow(self.tab_widget, device_info.name, self.untab)
tab_window._info = device_info
tab_window.add_callback_on_tab(lambda index:
self.ipcon.get_connection_state() == IPConnection.CONNECTION_STATE_PENDING and \
self.tab_widget.setTabEnabled(index, False),
'main_window_disable_tab_if_connection_pending')
layout = QVBoxLayout(tab_window)
info_bars = [QHBoxLayout(), QHBoxLayout()]
# uid
info_bars[0].addWidget(QLabel('UID:'))
label = QLabel('{0}'.format(device_info.uid))
label.setTextInteractionFlags(Qt.TextSelectableByMouse |
Qt.TextSelectableByKeyboard)
info_bars[0].addWidget(label)
info_bars[0].addSpacerItem(QSpacerItem(20, 1, QSizePolicy.Preferred))
# firmware version
label_version_name = QLabel('Version:')
label_version = QLabel('Querying...')
button_update = QPushButton(QIcon(self.button_update_pixmap_normal), 'Update')
button_update.installEventFilter(self)
if isinstance(device_info, infos.BrickREDInfo):
button_update.clicked.connect(self.show_red_brick_update)
elif device_info.type == 'brick':
button_update.clicked.connect(lambda: self.show_brick_update(device_info.url_part))
elif device_info.type == 'bricklet':
button_update.clicked.connect(lambda: self.show_bricklet_update(device_info.connected_uid, device_info.position))
if not device_info.plugin.has_custom_version(label_version_name, label_version):
label_version_name.setText('FW Version:')
label_version.setText(infos.get_version_string(device_info.plugin.firmware_version))
info_bars[0].addWidget(label_version_name)
info_bars[0].addWidget(label_version)
info_bars[0].addWidget(button_update)
button_update.hide()
tab_window.button_update = button_update
info_bars[0].addSpacerItem(QSpacerItem(20, 1, QSizePolicy.Preferred))
# timeouts
info_bars[0].addWidget(QLabel('Timeouts:'))
label_timeouts = QLabel('0')
info_bars[0].addWidget(label_timeouts)
info_bars[0].addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# connected uid
if device_info.connected_uid != '0':
info_bars[1].addWidget(QLabel('Connected to:'))
button = QToolButton()
button.setText(device_info.connected_uid)
button.clicked.connect(lambda: self.show_plugin(device_info.connected_uid))
device_info.plugin.button_parent = button
info_bars[1].addWidget(button)
info_bars[1].addSpacerItem(QSpacerItem(20, 1, QSizePolicy.Preferred))
# position
info_bars[1].addWidget(QLabel('Position:'))
label_position = QLabel('{0}'.format(device_info.position.title()))
device_info.plugin.label_position = label_position
info_bars[1].addWidget(label_position)
info_bars[1].addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# configs
configs = device_info.plugin.get_configs()
def config_changed(combobox):
i = combobox.currentIndex()
if i < 0:
return
combobox.itemData(i).trigger()
if len(configs) > 0:
for cfg in configs:
if cfg[1] != None:
combobox = QComboBox()
for i, item in enumerate(cfg[2]):
combobox.addItem(item.text(), item)
item.triggered.connect(functools.partial(combobox.setCurrentIndex, i))
combobox.currentIndexChanged.connect(functools.partial(config_changed, combobox))
info_bars[cfg[0]].addWidget(QLabel(cfg[1]))
info_bars[cfg[0]].addWidget(combobox)
elif len(cfg[2]) > 0:
checkbox = QCheckBox(cfg[2][0].text())
cfg[2][0].toggled.connect(checkbox.setChecked)
checkbox.toggled.connect(cfg[2][0].setChecked)
info_bars[cfg[0]].addWidget(checkbox)
# actions
actions = device_info.plugin.get_actions()
if len(actions) > 0:
for action in actions:
if action[1] != None:
button = QPushButton(action[1])
menu = QMenu()
for item in action[2]:
menu.addAction(item)
button.setMenu(menu)
elif len(action[2]) > 0:
button = QPushButton(action[2][0].text())
button.clicked.connect(action[2][0].trigger)
info_bars[action[0]].addWidget(button)
def more_clicked(button, info_bar):
visible = button.text().replace('&', '') == 'More' # remove &s, they mark the buttons hotkey
if visible:
button.setText('Less')
else:
button.setText('More')
for i in range(info_bar.count()):
widget = info_bar.itemAt(i).widget()
if widget != None:
widget.setVisible(visible)
more_button = QPushButton('More')
more_button.clicked.connect(lambda: more_clicked(more_button, info_bars[1]))
info_bars[0].addWidget(more_button)
for i in range(info_bars[1].count()):
widget = info_bars[1].itemAt(i).widget()
if widget != None:
widget.hide()
layout.addLayout(info_bars[0])
layout.addLayout(info_bars[1])
line = QFrame()
line.setObjectName("MainWindow_line")
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
device_info.plugin.label_timeouts = label_timeouts
device_info.plugin.label_version = label_version
device_info.plugin.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(line)
if device_info.plugin.has_comcu:
device_info.plugin.widget_bootloader = COMCUBootloader(ipcon, device_info)
device_info.plugin.widget_bootloader.hide()
layout.addWidget(device_info.plugin.widget_bootloader)
layout.addWidget(device_info.plugin, 1)
return tab_window
def create_tab_window(self, device_info):
tab_window = TabWindow(self.tab_widget, device_info.name, self.untab)
tab_window._info = device_info
tab_window.set_callback_on_tab(lambda index:
self.ipcon.get_connection_state() == IPConnection.CONNECTION_STATE_PENDING and \
self.tab_widget.setTabEnabled(index, False))
layout = QVBoxLayout(tab_window)
info_bar = QHBoxLayout()
# uid
info_bar.addWidget(QLabel('UID:'))
label = QLabel('{0}'.format(device_info.uid))
label.setTextInteractionFlags(Qt.TextSelectableByMouse
| Qt.TextSelectableByKeyboard)
info_bar.addWidget(label)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# connected uid
if device_info.connected_uid != '0':
info_bar.addWidget(QLabel('Connected to:'))
button = QToolButton()
button.setText(device_info.connected_uid)
button.clicked.connect(
lambda: self.show_plugin(device_info.connected_uid))
info_bar.addWidget(button)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# position
info_bar.addWidget(QLabel('Position:'))
info_bar.addWidget(QLabel('{0}'.format(device_info.position.upper())))
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# firmware version
label_version_name = QLabel('Version:')
label_version = QLabel('...')
if not device_info.plugin.has_custom_version(label_version_name,
label_version):
label_version_name.setText('FW Version:')
label_version.setText(
infos.get_version_string(device_info.plugin.firmware_version))
info_bar.addWidget(label_version_name)
info_bar.addWidget(label_version)
info_bar.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding))
# timeouts
info_bar.addWidget(QLabel('Timeouts:'))
label_timeouts = QLabel('0')
info_bar.addWidget(label_timeouts)
layout.addLayout(info_bar)
# actions
actions = device_info.plugin.get_actions()
if actions != None:
if type(actions) == QAction:
button = QPushButton(actions.text())
button.clicked.connect(actions.trigger)
else:
button = QToolButton()
button.setText(actions[0])
button.setPopupMode(QToolButton.InstantPopup)
button.setToolButtonStyle(Qt.ToolButtonTextOnly)
button.setArrowType(Qt.DownArrow)
button.setAutoRaise(True)
menu = QMenu(actions[0])
button.setMenu(menu)
for action in actions[1]:
menu.addAction(action)
info_bar.addSpacerItem(QSpacerItem(40, 20, QSizePolicy.Expanding))
info_bar.addWidget(button)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
device_info.plugin.label_timeouts = label_timeouts
device_info.plugin.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(line)
layout.addWidget(device_info.plugin)
return tab_window
