def rebuild(self):
""" Clear out all existing widgets, and populate the list using the
template file and data source."""
self.clear()
if (not self.templateFilename) or (not self.data):
return
self.setUpdatesEnabled(False)
layout_class = layout_class_for_type[self.layoutType]
if type(self.layout()) != layout_class:
if self.layout() is not None:
# Trick to remove the existing layout by re-parenting it in an empty widget.
QWidget().setLayout(self.layout())
l = layout_class(self)
self.setLayout(l)
with pydm.data_plugins.connection_queue(defer_connections=True):
for i, variables in enumerate(self.data):
if is_qt_designer() and i > self.countShownInDesigner - 1:
break
w = self.open_template_file(variables)
if w is None:
w = QLabel()
w.setText(
"No Template Loaded. Data: {}".format(variables))
w.setParent(self)
self.layout().addWidget(w)
self.setUpdatesEnabled(True)
pydm.data_plugins.establish_queued_connections()
def rebuild(self):
""" Clear out all existing widgets, and populate the list using the
template file and data source."""
self.clear()
if (not self.templateFilename) or (not self.data):
return
self.setUpdatesEnabled(False)
layout_class = layout_class_for_type[self.layoutType]
if type(self.layout()) != layout_class:
if self.layout() is not None:
# Trick to remove the existing layout by re-parenting it in an empty widget.
QWidget().setLayout(self.layout())
l = layout_class(self)
self.setLayout(l)
with pydm.data_plugins.connection_queue():
for i, variables in enumerate(self.data):
if is_qt_designer() and i > self.countShownInDesigner - 1:
break
w = self.open_template_file(variables)
if w is None:
w = QLabel()
w.setText("No Template Loaded. Data: {}".format(variables))
w.setParent(self)
self.layout().addWidget(w)
self.setUpdatesEnabled(True)
def displayFormat(self, new_type):
if self._display_format_type == new_type:
return
self._display_format_type = new_type
if not is_qt_designer() or config.DESIGNER_ONLINE:
# Trigger the update of display format
self.value_changed(self.value)
def initial_sort_header(self, header: str):
self._initial_sort_header = header
if not is_qt_designer():
# Do a sort after a short timer
# HACK: this is because it doesn't work if done immediately
# This is due to some combination of qt designer properties being
# applied in some random order post-__init__ combined with it
# taking a short bit of time for the items to be ready to sort.
# Some items will never connect and never be ready to sort,
# so for now we'll do a best-effort one-second wait.
timer = QtCore.QTimer(parent=self)
timer.singleShot(1000, self.initial_sort)
def disconnect(self, destroying=False):
"""
Disconnect a PyDMChannel
"""
if is_qt_designer() and not config.DESIGNER_ONLINE:
return
try:
plugin = plugin_for_address(self.address)
if not plugin:
return
plugin.remove_connection(self, destroying=destroying)
except Exception as exc:
logger.exception("Unable to remove connection " "for %r", self)
def connect(self):
"""
Connect a PyDMChannel to the proper PyDMPlugin
"""
if is_qt_designer() and not config.DESIGNER_ONLINE:
return
logger.debug("Connecting %r", self.address)
# Connect to proper PyDMPlugin
try:
pydm.data_plugins.establish_connection(self)
except Exception:
logger.exception("Unable to make proper connection "
"for %r", self)
def disconnect(self, destroying=False):
"""
Disconnect a PyDMChannel
"""
if is_qt_designer() and not config.DESIGNER_ONLINE:
return
try:
plugin = pydm.data_plugins.plugin_for_address(self.address)
if not plugin:
return
plugin.remove_connection(self, destroying=destroying)
except Exception as exc:
logger.exception("Unable to remove connection "
"for %r", self)
def connect(self):
"""
Connect a PyDMChannel to the proper PyDMPlugin
"""
if not self.address:
return
if is_qt_designer() and not config.DESIGNER_ONLINE:
return
logger.debug("Connecting %r", self.address)
# Connect to proper PyDMPlugin
try:
pydm.data_plugins.establish_connection(self)
except Exception:
logger.exception("Unable to make proper connection "
"for %r", self)
def dataSource(self, data_source):
"""
Sets the path to the JSON file or a valid JSON string to fill in each
instance of the template.
For example, if you build a template that contains two macro variables,
${NAME} and ${UNIT}, your JSON file should be a list of dictionaries,
each with keys for NAME and UNIT, like this:
[{"NAME": "First Device", "UNIT": 1}, {"NAME": "Second Device", "UNIT": 2}]
Parameters
-------
data_source : str
"""
if data_source != self._data_source:
self._data_source = data_source
if self._data_source:
is_json, data = self._is_json(data_source)
if is_json:
logger.debug('TemplateRepeater dataSource is a valid JSON.')
self.data = data
else:
logger.debug('TemplateRepeater dataSource is not a valid JSON. Assuming it is a file path.')
try:
parent_display = self.find_parent_display()
base_path = None
if parent_display:
base_path = os.path.dirname(
parent_display.loaded_file())
fname = find_file(self._data_source, base_path=base_path)
if not fname:
if not is_qt_designer():
logger.error('Cannot locate data source file {} for PyDMTemplateRepeater.'.format(fname))
self.data = []
else:
with open(fname) as f:
try:
self.data = json.load(f)
except ValueError:
logger.error('Failed to parse data source file {} for PyDMTemplateRepeater.'.format(fname))
self.data = []
except IOError as e:
self.data = []
else:
self.clear()
def add_connection(self, channel):
from pydm.utilities import is_qt_designer
with self.lock:
address = self.get_address(channel)
# If this channel is already connected to this plugin lets ignore
if channel in self.channels:
return
if (is_qt_designer() and not config.DESIGNER_ONLINE
and not self.designer_online_by_default):
return
self.channels.add(channel)
if address in self.connections:
self.connections[address].add_listener(channel)
else:
self.connections[address] = self.connection_class(
channel, address, self.protocol)
def __init__(self, parent=None):
self._brush = QBrush(QColor(0, 255, 0), Qt.SolidPattern)
self._original_brush = None
self._rotation = 0
self._pen_style = Qt.SolidLine
self._pen = QPen(self._pen_style)
self._pen.setCosmetic(True)
self._pen_width = 1.0
self._pen_color = QColor(0, 0, 0)
self._pen.setWidthF(self._pen_width)
self._pen.setColor(self._pen_color)
self._original_pen_style = self._pen_style
self._original_pen_color = self._pen_color
super(BaseSymbolIcon, self).__init__(parent=parent)
self.setObjectName("icon")
if not is_qt_designer():
# We should install the Event Filter only if we are running
# and not at the Designer
self.installEventFilter(self)
def countShownInDesigner(self, new_count):
"""
The number of instances to show in Qt Designer. This property has no
effect outside of Designer.
Parameters
----------
new_count : int
"""
if not is_qt_designer():
return
try:
new_count = int(new_count)
except ValueError:
logger.exception("Couldn't convert {} to integer.".format(new_count))
return
new_count = max(new_count, 0)
if new_count != self._count_shown_in_designer:
self._count_shown_in_designer = new_count
self.rebuild()
def rebuild(self):
""" Clear out all existing widgets, and populate the list using the
template file and data source."""
self.clear()
if (not self.templateFilename) or (not self.data):
return
self.setUpdatesEnabled(False)
layout_class = layout_class_for_type[self.layoutType]
if type(self.layout()) != layout_class:
if self.layout() is not None:
# Trick to remove the existing layout by re-parenting it in an empty widget.
QWidget().setLayout(self.layout())
l = layout_class(self)
self.setLayout(l)
self.layout().setSpacing(self._temp_layout_spacing)
try:
with pydm.data_plugins.connection_queue(defer_connections=True):
for i, variables in enumerate(self.data):
if is_qt_designer() and i > self.countShownInDesigner - 1:
break
w = self.open_template_file(variables)
if w is None:
w = QLabel()
w.setText(
"No Template Loaded. Data: {}".format(variables))
w.setParent(self)
self.layout().addWidget(w)
except:
logger.exception('Template repeater failed to rebuild.')
finally:
# If issues happen during the rebuild we should still enable
# updates and establish connection for the widgets added.
# Moreover, if we dont call establish_queued_connections
# the queue will never be emptied and new connections will be
# staled.
self.setUpdatesEnabled(True)
pydm.data_plugins.establish_queued_connections()
def preload(self, exec_preload):
self._preload = exec_preload
if self._preload and self._suite is None and not is_qt_designer():
self.create_suite()
