def createIntegerSpinner(self, minimum, maximum):
spinner = QSpinBox()
spinner.setEnabled(False)
spinner.setMinimumWidth(75)
spinner.setRange(minimum, maximum)
spinner.setKeyboardTracking(False)
spinner.editingFinished.connect(self.plotScaleChanged)
spinner.valueChanged.connect(self.plotScaleChanged)
return spinner
def _initInsertPositionTableWithExtents(self, axes, mx):
positionTbl = self.positionWidget
tblHeaders = ["insert at", "max"]
positionTbl.setColumnCount(len(tblHeaders))
positionTbl.setHorizontalHeaderLabels(tblHeaders)
positionTbl.resizeColumnsToContents()
tagged_insert = collections.OrderedDict(zip(axes, self.imageOffsets))
tagged_max = collections.OrderedDict(zip(axes, mx))
self._tagged_insert = tagged_insert
positionTbl.setRowCount(len(tagged_insert))
positionTbl.setVerticalHeaderLabels(tagged_insert.keys())
self._insert_position_boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_max.items()):
# Init min/max spinboxes
default_insert = tagged_insert[axis_key] or 0
default_max = tagged_max[axis_key] or extent
insertBox = QSpinBox(self)
maxBox = QLabel(str(default_max), self)
insertBox.setValue(0)
insertBox.setMinimum(0)
insertBox.setMaximum(extent)
insertBox.setEnabled( tagged_insert[axis_key] is not None )
if insertBox.isEnabled():
insertBox.setValue( default_insert )
# TODO: maxBox shouldn't be in tab list (but it still is)
maxBox.setTextInteractionFlags(Qt.NoTextInteraction)
maxBox.setFocusPolicy(Qt.NoFocus)
maxBox.setEnabled(False)
insertBox.valueChanged.connect( self._updatePosition )
positionTbl.setCellWidget( row, 0, insertBox )
positionTbl.setCellWidget( row, 1, maxBox )
self._insert_position_boxes[axis_key] = (insertBox, maxBox)
positionTbl.resizeColumnsToContents()
def _initInsertPositionTableWithExtents(self, axes, mx):
positionTbl = self.positionWidget
tblHeaders = ["insert at", "max"]
positionTbl.setColumnCount(len(tblHeaders))
positionTbl.setHorizontalHeaderLabels(tblHeaders)
positionTbl.resizeColumnsToContents()
tagged_insert = collections.OrderedDict(zip(axes, self.imageOffsets))
tagged_max = collections.OrderedDict(zip(axes, mx))
self._tagged_insert = tagged_insert
positionTbl.setRowCount(len(tagged_insert))
positionTbl.setVerticalHeaderLabels(tagged_insert.keys())
self._insert_position_boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_max.items()):
# Init min/max spinboxes
default_insert = tagged_insert[axis_key] or 0
default_max = tagged_max[axis_key] or extent
insertBox = QSpinBox(self)
maxBox = QLabel(str(default_max), self)
insertBox.setValue(0)
insertBox.setMinimum(0)
insertBox.setMaximum(extent)
insertBox.setEnabled(tagged_insert[axis_key] is not None)
if insertBox.isEnabled():
insertBox.setValue(default_insert)
# TODO: maxBox shouldn't be in tab list (but it still is)
maxBox.setTextInteractionFlags(Qt.NoTextInteraction)
maxBox.setFocusPolicy(Qt.NoFocus)
maxBox.setEnabled(False)
insertBox.valueChanged.connect(self._updatePosition)
positionTbl.setCellWidget(row, 0, insertBox)
positionTbl.setCellWidget(row, 1, maxBox)
self._insert_position_boxes[axis_key] = (insertBox, maxBox)
positionTbl.resizeColumnsToContents()
def _initLabelMappingTableWithExtents(self):
mappingTbl = self.mappingWidget
max_labels, read_labels_info = self._labelInfo
labels, label_counts = read_labels_info
label_mapping = self.labelMapping
mappings = zip(labels, [label_mapping[i] for i in labels],
label_counts)
tblHeaders = ["map", "to", "px count"]
mappingTbl.setColumnCount(len(tblHeaders))
mappingTbl.setHorizontalHeaderLabels(tblHeaders)
mappingTbl.resizeColumnsToContents()
mappingTbl.setRowCount(len(labels))
mappingTbl.setVerticalHeaderLabels(map(lambda x: str(x), labels))
self._insert_mapping_boxes.clear()
for row, (label_from, label_to, px_cnt) in enumerate(mappings):
enabledBox = QCheckBox(self)
mapToBox = QSpinBox(self)
pxCountBox = QLabel(str(px_cnt), self)
enabledBox.setChecked(label_to > 0)
mapToBox.setMinimum(1 if label_to else 0)
mapToBox.setMaximum(max_labels if label_to else 0)
mapToBox.setValue(label_to)
mapToBox.setEnabled(label_to > 0)
enabledBox.stateChanged.connect(self._updateMappingEnabled)
mapToBox.valueChanged.connect(self._updateMapping)
# TODO: pxCountBox shouldn't be in tab list (but it still is)
pxCountBox.setTextInteractionFlags(Qt.NoTextInteraction)
pxCountBox.setFocusPolicy(Qt.NoFocus)
pxCountBox.setEnabled(False)
mappingTbl.setCellWidget(row, 0, enabledBox)
mappingTbl.setCellWidget(row, 1, mapToBox)
mappingTbl.setCellWidget(row, 2, pxCountBox)
self._insert_mapping_boxes[label_from] = (enabledBox, mapToBox)
mappingTbl.resizeColumnsToContents()
def _initLabelMappingTableWithExtents(self):
mappingTbl = self.mappingWidget
max_labels, read_labels_info = self._labelInfo
labels, label_counts = read_labels_info
label_mapping = self.labelMapping
mappings = zip(labels, [label_mapping[i] for i in labels], label_counts)
tblHeaders = ["map", "to", "px count"]
mappingTbl.setColumnCount(len(tblHeaders))
mappingTbl.setHorizontalHeaderLabels(tblHeaders)
mappingTbl.resizeColumnsToContents()
mappingTbl.setRowCount( len(labels) )
mappingTbl.setVerticalHeaderLabels( map(lambda x: str(x), labels) )
self._insert_mapping_boxes.clear()
for row, (label_from, label_to, px_cnt) in enumerate(mappings):
enabledBox = QCheckBox(self)
mapToBox = QSpinBox(self)
pxCountBox = QLabel(str(px_cnt), self)
enabledBox.setChecked(label_to > 0)
mapToBox.setMinimum(1 if label_to else 0)
mapToBox.setMaximum(max_labels if label_to else 0)
mapToBox.setValue(label_to)
mapToBox.setEnabled(label_to > 0)
enabledBox.stateChanged.connect( self._updateMappingEnabled )
mapToBox.valueChanged.connect( self._updateMapping )
# TODO: pxCountBox shouldn't be in tab list (but it still is)
pxCountBox.setTextInteractionFlags(Qt.NoTextInteraction)
pxCountBox.setFocusPolicy(Qt.NoFocus)
pxCountBox.setEnabled(False)
mappingTbl.setCellWidget( row, 0, enabledBox )
mappingTbl.setCellWidget( row, 1, mapToBox )
mappingTbl.setCellWidget( row, 2, pxCountBox )
self._insert_mapping_boxes[label_from] = (enabledBox, mapToBox)
mappingTbl.resizeColumnsToContents()
def addSpinBox(self, name):
sb = QSpinBox(self)
sb.setEnabled(True)
sb.setMinimumSize(QSize(60, 20))
sb.setMaximumSize(QSize(60, 20))
sb.setWrapping(False)
sb.setFrame(True)
sb.setButtonSymbols(QSpinBox.NoButtons)
sb.setAccelerated(True)
sb.setCorrectionMode(QSpinBox.CorrectToPreviousValue)
sb.setKeyboardTracking(True)
sb.setMinimum(0)
sb.setMaximum(99999999)
sb.setSingleStep(1000)
sb.setAlignment(Qt.AlignRight|Qt.AlignTrailing|Qt.AlignVCenter)
sb.setProperty("value", 0)
sb.setObjectName(name)
return sb
def addSpinBox(self, name):
sb = QSpinBox(self)
sb.setEnabled(True)
sb.setMinimumSize(QSize(60, 20))
sb.setMaximumSize(QSize(60, 20))
sb.setWrapping(False)
sb.setFrame(True)
sb.setButtonSymbols(QSpinBox.NoButtons)
sb.setAccelerated(True)
sb.setCorrectionMode(QSpinBox.CorrectToPreviousValue)
sb.setKeyboardTracking(True)
sb.setMinimum(0)
sb.setMaximum(99999999)
sb.setSingleStep(1000)
sb.setAlignment(Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter)
sb.setProperty("value", 0)
sb.setObjectName(name)
return sb
class CheckBoxEdit(QWidget):
def __init__(self, label='', value=0, parent=None):
super(CheckBoxEdit, self).__init__(parent)
self.check = QCheckBox(label)
self.columnSpin = QSpinBox()
self.columnSpin.setRange(0, 20)
self.columnSpin.setValue(value)
lay = QHBoxLayout()
lay.addWidget(self.check)
lay.addWidget(self.columnSpin)
self.setLayout(lay)
self.column = 0
self.columnSpin.setEnabled(False)
self.check.stateChanged.connect(self.columnSpin.setEnabled)
self.columnSpin.valueChanged[int].connect(self.setColumn)
def setColumn(self, column):
self.column = column
def _get_pos_widget(name, backgroundColor, foregroundColor):
label = QLabel()
label.setAttribute(Qt.WA_TransparentForMouseEvents, True)
pixmap = QPixmap(25*10, 25*10)
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(foregroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, name)
brush = QBrush(foregroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20,20),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
label.setPixmap(pixmap)
spinbox = QSpinBox()
spinbox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
spinbox.setEnabled(False)
spinbox.setAlignment(Qt.AlignCenter)
spinbox.setToolTip("{0} Spin Box".format(name))
spinbox.setButtonSymbols(QAbstractSpinBox.NoButtons)
spinbox.setMaximumHeight(20)
spinbox.setMaximum(9999)
font = spinbox.font()
font.setPixelSize(14)
spinbox.setFont(font)
sheet = TEMPLATE.format(foregroundColor.name(),
backgroundColor.name())
spinbox.setStyleSheet(sheet)
return label, spinbox
def _get_pos_widget(name, backgroundColor, foregroundColor):
label = QLabel()
label.setAttribute(Qt.WA_TransparentForMouseEvents, True)
pixmap = QPixmap(25*10, 25*10)
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(foregroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, name)
brush = QBrush(foregroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20,20),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
label.setPixmap(pixmap)
spinbox = QSpinBox()
spinbox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
spinbox.setEnabled(False)
spinbox.setAlignment(Qt.AlignCenter)
spinbox.setToolTip("{0} Spin Box".format(name))
spinbox.setButtonSymbols(QAbstractSpinBox.NoButtons)
spinbox.setMaximumHeight(20)
spinbox.setMaximum(9999)
font = spinbox.font()
font.setPixelSize(14)
spinbox.setFont(font)
sheet = TEMPLATE.format(foregroundColor.name(),
backgroundColor.name())
spinbox.setStyleSheet(sheet)
return label, spinbox
class EditGeometryProperties(QDialog):
force = True
allow_update = True
def __init__(self, data, win_parent=None):
"""
+------------------+
| Edit Actor Props |
+------------------+------+
| Name1 |
| Name2 |
| Name3 |
| Name4 |
| |
| Active_Name main |
| Color box |
| Line_Width 2 |
| Point_Size 2 |
| Bar_Scale 2 |
| Opacity 0.5 |
| Show/Hide |
| |
| Apply OK Cancel |
+-------------------------+
"""
QDialog.__init__(self, win_parent)
self.setWindowTitle('Edit Geometry Properties')
#default
self.win_parent = win_parent
self.out_data = data
self.keys = sorted(data.keys())
self.keys = data.keys()
keys = self.keys
nrows = len(keys)
self.active_key = 'main'#keys[0]
items = keys
header_labels = ['Groups']
table_model = Model(items, header_labels, self)
view = CustomQTableView(self) #Call your custom QTableView here
view.setModel(table_model)
if qt_version == 4:
view.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.table = view
actor_obj = data[self.active_key]
name = actor_obj.name
line_width = actor_obj.line_width
point_size = actor_obj.point_size
bar_scale = actor_obj.bar_scale
opacity = actor_obj.opacity
color = actor_obj.color
show = actor_obj.is_visible
self.representation = actor_obj.representation
# table
header = self.table.horizontalHeader()
header.setStretchLastSection(True)
self._default_is_apply = False
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(name))
self.name_edit.setDisabled(True)
self.color = QLabel("Color:")
self.color_edit = QPushButton()
#self.color_edit.setFlat(True)
color = self.out_data[self.active_key].color
qcolor = QtGui.QColor()
qcolor.setRgb(*color)
#print('color =%s' % str(color))
palette = QtGui.QPalette(self.color_edit.palette()) # make a copy of the palette
#palette.setColor(QtGui.QPalette.Active, QtGui.QPalette.Base, \
#qcolor)
palette.setColor(QtGui.QPalette.Background, QtGui.QColor('blue')) # ButtonText
self.color_edit.setPalette(palette)
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.use_slider = True
self.is_opacity_edit_active = False
self.is_opacity_edit_slider_active = False
self.is_line_width_edit_active = False
self.is_line_width_edit_slider_active = False
self.is_point_size_edit_active = False
self.is_point_size_edit_slider_active = False
self.is_bar_scale_edit_active = False
self.is_bar_scale_edit_slider_active = False
self.opacity = QLabel("Opacity:")
self.opacity_edit = QDoubleSpinBox(self)
self.opacity_edit.setRange(0.1, 1.0)
self.opacity_edit.setDecimals(1)
self.opacity_edit.setSingleStep(0.1)
self.opacity_edit.setValue(opacity)
if self.use_slider:
self.opacity_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.opacity_slider_edit.setRange(1, 10)
self.opacity_slider_edit.setValue(opacity * 10)
self.opacity_slider_edit.setTickInterval(1)
self.opacity_slider_edit.setTickPosition(QSlider.TicksBelow)
self.line_width = QLabel("Line Width:")
self.line_width_edit = QSpinBox(self)
self.line_width_edit.setRange(1, 15)
self.line_width_edit.setSingleStep(1)
self.line_width_edit.setValue(line_width)
if self.use_slider:
self.line_width_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.line_width_slider_edit.setRange(1, 15)
self.line_width_slider_edit.setValue(line_width)
self.line_width_slider_edit.setTickInterval(1)
self.line_width_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation in ['point', 'surface']:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
self.line_width_slider_edit.setEnabled(False)
self.point_size = QLabel("Point Size:")
self.point_size_edit = QSpinBox(self)
self.point_size_edit.setRange(1, 15)
self.point_size_edit.setSingleStep(1)
self.point_size_edit.setValue(point_size)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
if self.use_slider:
self.point_size_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.point_size_slider_edit.setRange(1, 15)
self.point_size_slider_edit.setValue(point_size)
self.point_size_slider_edit.setTickInterval(1)
self.point_size_slider_edit.setTickPosition(QSlider.TicksBelow)
self.point_size_slider_edit.setVisible(False)
if self.representation in ['wire', 'surface']:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.bar_scale = QLabel("Bar Scale:")
self.bar_scale_edit = QDoubleSpinBox(self)
#self.bar_scale_edit.setRange(0.01, 1.0) # was 0.1
#self.bar_scale_edit.setRange(0.05, 5.0)
self.bar_scale_edit.setDecimals(1)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
self.bar_scale_edit.setSingleStep(0.1)
self.bar_scale_edit.setValue(bar_scale)
#if self.use_slider:
#self.bar_scale_slider_edit = QSlider(QtCore.Qt.Horizontal)
#self.bar_scale_slider_edit.setRange(1, 100) # 1/0.05 = 100/5.0
#self.bar_scale_slider_edit.setValue(opacity * 0.05)
#self.bar_scale_slider_edit.setTickInterval(10)
#self.bar_scale_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation != 'bar':
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setEnabled(False)
# show/hide
self.checkbox_show = QCheckBox("Show")
self.checkbox_hide = QCheckBox("Hide")
self.checkbox_show.setChecked(show)
self.checkbox_hide.setChecked(not show)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
# closing
# self.apply_button = QPushButton("Apply")
#if self._default_is_apply:
#self.apply_button.setDisabled(True)
# self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Close")
self.create_layout()
self.set_connections()
def on_update_geometry_properties_window(self, data):
"""Not Implemented"""
return
new_keys = sorted(data.keys())
if self.active_key in new_keys:
i = new_keys.index(self.active_key)
else:
i = 0
self.table.update_data(new_keys)
self.out_data = data
self.update_active_key(i)
def update_active_key(self, index):
"""
Parameters
----------
index : PyQt4.QtCore.QModelIndex
the index of the list
Internal Parameters
-------------------
name : str
the name of obj
obj : CoordProperties, AltGeometry
the storage object for things like line_width, point_size, etc.
"""
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.bar_scale = self.bar_scale_edit.value()
old_obj.opacity = self.opacity_edit.value()
old_obj.is_visible = self.checkbox_show.isChecked()
if qt_version == 4:
name = str(index.data().toString())
else:
name = str(index.data())
print('name = %r' % name)
#i = self.keys.index(self.active_key)
self.active_key = name
self.name_edit.setText(name)
obj = self.out_data[name]
if isinstance(obj, CoordProperties):
opacity = 1.0
representation = 'coord'
is_visible = obj.is_visible
elif isinstance(obj, AltGeometry):
line_width = obj.line_width
point_size = obj.point_size
bar_scale = obj.bar_scale
opacity = obj.opacity
representation = obj.representation
is_visible = obj.is_visible
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.allow_update = False
self.force = False
self.line_width_edit.setValue(line_width)
self.point_size_edit.setValue(point_size)
self.bar_scale_edit.setValue(bar_scale)
self.force = True
self.allow_update = True
else:
raise NotImplementedError(obj)
allowed_representations = [
'main', 'surface', 'coord', 'toggle', 'wire', 'point', 'bar']
if self.representation != representation:
self.representation = representation
if representation not in allowed_representations:
msg = 'name=%r; representation=%r is invalid\nrepresentations=%r' % (
name, representation, allowed_representations)
if self.representation == 'coord':
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
if self.use_slider:
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setVisible(True)
self.color_edit.setVisible(True)
self.line_width.setVisible(True)
self.line_width_edit.setVisible(True)
self.point_size.setVisible(True)
self.point_size_edit.setVisible(True)
self.bar_scale.setVisible(True)
#self.bar_scale_edit.setVisible(True)
self.opacity.setVisible(True)
self.opacity_edit.setVisible(True)
if self.use_slider:
self.opacity_slider_edit.setVisible(True)
self.line_width_slider_edit.setVisible(True)
self.point_size_slider_edit.setVisible(True)
#self.bar_scale_slider_edit.setVisible(True)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
self.line_width.setEnabled(True)
self.line_width_edit.setEnabled(True)
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
show_points = False
show_line_width = True
show_bar_scale = False
if self.use_slider:
self.line_width_slider_edit.setEnabled(True)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setEnabled(True)
self.color_edit.setEnabled(True)
show_points = False
if self.representation in ['point', 'wire+point']:
show_points = True
show_line_width = False
if self.representation in ['wire', 'wire+point', 'bar']:
show_line_width = True
if representation == 'bar':
show_bar_scale = True
else:
show_bar_scale = False
#self.bar_scale_button.setVisible(show_bar_scale)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
#if self.use_slider:
#self.bar_scale_slider_edit.setEnabled(False)
self.point_size.setEnabled(show_points)
self.point_size_edit.setEnabled(show_points)
self.point_size.setVisible(show_points)
self.point_size_edit.setVisible(show_points)
self.line_width.setEnabled(show_line_width)
self.line_width_edit.setEnabled(show_line_width)
self.bar_scale.setEnabled(show_bar_scale)
self.bar_scale_edit.setEnabled(show_bar_scale)
self.bar_scale.setVisible(show_bar_scale)
self.bar_scale_edit.setVisible(show_bar_scale)
if self.use_slider:
self.point_size_slider_edit.setEnabled(show_points)
self.point_size_slider_edit.setVisible(show_points)
self.line_width_slider_edit.setEnabled(show_line_width)
#if self.representation in ['wire', 'surface']:
self.opacity_edit.setValue(opacity)
#if self.use_slider:
#self.opacity_slider_edit.setValue(opacity*10)
self.checkbox_show.setChecked(is_visible)
self.checkbox_hide.setChecked(not is_visible)
passed = self.on_validate()
#self.on_apply(force=True) # TODO: was turned on...do I want this???
#self.allow_update = True
#def on_name_select(self):
#print('on_name_select')
#return
def create_layout(self):
ok_cancel_box = QHBoxLayout()
# ok_cancel_box.addWidget(self.apply_button)
# ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid = QGridLayout()
irow = 0
grid.addWidget(self.name, irow, 0)
grid.addWidget(self.name_edit, irow, 1)
irow += 1
grid.addWidget(self.color, irow, 0)
grid.addWidget(self.color_edit, irow, 1)
irow += 1
grid.addWidget(self.opacity, irow, 0)
if self.use_slider:
grid.addWidget(self.opacity_edit, irow, 2)
grid.addWidget(self.opacity_slider_edit, irow, 1)
else:
grid.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid.addWidget(self.line_width, irow, 0)
if self.use_slider:
grid.addWidget(self.line_width_edit, irow, 2)
grid.addWidget(self.line_width_slider_edit, irow, 1)
else:
grid.addWidget(self.line_width_edit, irow, 1)
irow += 1
grid.addWidget(self.point_size, irow, 0)
if self.use_slider:
grid.addWidget(self.point_size_edit, irow, 2)
grid.addWidget(self.point_size_slider_edit, irow, 1)
else:
grid.addWidget(self.point_size_edit, irow, 1)
irow += 1
grid.addWidget(self.bar_scale, irow, 0)
if self.use_slider and 0:
grid.addWidget(self.bar_scale_edit, irow, 2)
grid.addWidget(self.bar_scale_slider_edit, irow, 1)
else:
grid.addWidget(self.bar_scale_edit, irow, 1)
irow += 1
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
if 0:
vbox.addWidget(self.checkbox_show)
vbox.addWidget(self.checkbox_hide)
else:
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_show)
vbox1.addWidget(self.checkbox_hide)
vbox.addLayout(vbox1)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
# self.opacity_edit.connect(arg0, QObject, arg1)
if qt_version == 4:
self.connect(self.opacity_edit, QtCore.SIGNAL('valueChanged(double)'), self.on_opacity)
#self.connect(self.opacity_slider_edit, QtCore.SIGNAL('valueChanged(double)'), self.on_opacity)
#grid.addWidget(self.opacity_slider_edit, irow, 1)
# self.connect(self.line_width, QtCore.SIGNAL('valueChanged(int)'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('valueChanged(int)'), self.on_point_size)
# self.connect(self.line_width, QtCore.SIGNAL('valueChanged(const QString&)'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('valueChanged(const QString&)'), self.on_point_size)
self.connect(self.line_width_edit, QtCore.SIGNAL('valueChanged(int)'), self.on_line_width)
self.connect(self.point_size_edit, QtCore.SIGNAL('valueChanged(int)'), self.on_point_size)
self.connect(self.bar_scale_edit, QtCore.SIGNAL('valueChanged(double)'), self.on_bar_scale)
else:
self.opacity_edit.valueChanged.connect(self.on_opacity)
self.line_width_edit.valueChanged.connect(self.on_line_width)
self.point_size_edit.valueChanged.connect(self.on_point_size)
self.bar_scale_edit.valueChanged.connect(self.on_bar_scale)
if self.use_slider:
self.opacity_slider_edit.valueChanged.connect(self.on_opacity_slider)
self.line_width_slider_edit.valueChanged.connect(self.on_line_width_slider)
self.point_size_slider_edit.valueChanged.connect(self.on_point_size_slider)
#self.bar_scale_slider_edit.valueChanged.connect(self.on_bar_scale_slider)
# self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'), self.on_opacity)
# self.connect(self.line_width, QtCore.SIGNAL('clicked()'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('clicked()'), self.on_point_size)
if qt_version == 4:
self.connect(self.color_edit, QtCore.SIGNAL('clicked()'), self.on_color)
self.connect(self.checkbox_show, QtCore.SIGNAL('clicked()'), self.on_show)
self.connect(self.checkbox_hide, QtCore.SIGNAL('clicked()'), self.on_hide)
#self.connect(self.check_apply, QtCore.SIGNAL('clicked()'), self.on_check_apply)
# self.connect(self.apply_button, QtCore.SIGNAL('clicked()'), self.on_apply)
# self.connect(self.ok_button, QtCore.SIGNAL('clicked()'), self.on_ok)
self.connect(self.cancel_button, QtCore.SIGNAL('clicked()'), self.on_cancel)
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
else:
self.color_edit.clicked.connect(self.on_color)
self.checkbox_show.clicked.connect(self.on_show)
self.checkbox_hide.clicked.connect(self.on_hide)
self.cancel_button.clicked.connect(self.on_cancel)
# closeEvent
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def closeEvent(self, event):
self.on_cancel()
def on_color(self):
name = self.active_key
obj = self.out_data[name]
rgb_color_ints = obj.color
msg = name
col = QtGui.QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self, "Choose a %s color" % msg)
if col.isValid():
color = col.getRgbF()[:3]
obj.color = color
#print('new_color =', color)
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.on_apply(force=self.force)
def on_show(self):
name = self.active_key
is_checked = self.checkbox_show.isChecked()
self.out_data[name].is_visible = is_checked
self.on_apply(force=self.force)
def on_hide(self):
name = self.active_key
is_checked = self.checkbox_hide.isChecked()
self.out_data[name].is_visible = not is_checked
self.on_apply(force=self.force)
def on_line_width(self):
self.is_line_width_edit_active = True
name = self.active_key
line_width = self.line_width_edit.value()
self.out_data[name].line_width = line_width
if not self.is_line_width_edit_slider_active:
if self.use_slider:
self.line_width_slider_edit.setValue(line_width)
self.is_line_width_edit_active = False
self.on_apply(force=self.force)
self.is_line_width_edit_active = False
def on_line_width_slider(self):
self.is_line_width_edit_slider_active = True
name = self.active_key
line_width = self.line_width_slider_edit.value()
if not self.is_line_width_edit_active:
self.line_width_edit.setValue(line_width)
self.is_line_width_edit_slider_active = False
def on_point_size(self):
self.is_point_size_edit_active = True
name = self.active_key
point_size = self.point_size_edit.value()
self.out_data[name].point_size = point_size
if not self.is_point_size_edit_slider_active:
if self.use_slider:
self.point_size_slider_edit.setValue(point_size)
self.is_point_size_edit_active = False
self.on_apply(force=self.force)
self.is_point_size_edit_active = False
def on_point_size_slider(self):
self.is_point_size_edit_slider_active = True
name = self.active_key
point_size = self.point_size_slider_edit.value()
if not self.is_point_size_edit_active:
self.point_size_edit.setValue(point_size)
self.is_point_size_edit_slider_active = False
def on_bar_scale(self):
self.is_bar_scale_edit_active = True
name = self.active_key
float_bar_scale = self.bar_scale_edit.value()
self.out_data[name].bar_scale = float_bar_scale
if not self.is_bar_scale_edit_slider_active:
int_bar_scale = int(round(float_bar_scale * 20, 0))
#if self.use_slider:
#self.bar_scale_slider_edit.setValue(int_bar_scale)
self.is_bar_scale_edit_active = False
self.on_apply(force=self.force)
self.is_bar_scale_edit_active = False
def on_bar_scale_slider(self):
self.is_bar_scale_edit_slider_active = True
name = self.active_key
int_bar_scale = self.bar_scale_slider_edit.value()
if not self.is_bar_scale_edit_active:
float_bar_scale = int_bar_scale / 20.
self.bar_scale_edit.setValue(float_bar_scale)
self.is_bar_scale_edit_slider_active = False
def on_opacity(self):
self.is_opacity_edit_active = True
name = self.active_key
float_opacity = self.opacity_edit.value()
self.out_data[name].opacity = float_opacity
if not self.is_opacity_edit_slider_active:
int_opacity = int(round(float_opacity * 10, 0))
if self.use_slider:
self.opacity_slider_edit.setValue(int_opacity)
self.is_opacity_edit_active = False
self.on_apply(force=self.force)
self.is_opacity_edit_active = False
def on_opacity_slider(self):
self.is_opacity_edit_slider_active = True
name = self.active_key
int_opacity = self.opacity_slider_edit.value()
if not self.is_opacity_edit_active:
float_opacity = int_opacity / 10.
self.opacity_edit.setValue(float_opacity)
self.is_opacity_edit_slider_active = False
#def on_axis(self, text):
##print(self.combo_axis.itemText())
#self._axis = str(text)
#self.plane.setText('Point on %s? Plane:' % self._axis)
#self.point_a.setText('Point on %s Axis:' % self._axis)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def on_plane(self, text):
#self._plane = str(text)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
def on_check_apply(self):
is_checked = self.check_apply.isChecked()
self.apply_button.setDisabled(is_checked)
def _on_float(self, field):
try:
eval_float_from_string(field.text())
field.setStyleSheet("QLineEdit{background: white;}")
except ValueError:
field.setStyleSheet("QLineEdit{background: red;}")
#def on_default_name(self):
#self.name_edit.setText(str(self._default_name))
#self.name_edit.setStyleSheet("QLineEdit{background: white;}")
#def check_float(self, cell):
#text = cell.text()
#try:
#value = eval_float_from_string(text)
#cell.setStyleSheet("QLineEdit{background: white;}")
#return value, True
#except ValueError:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
#def check_name(self, cell):
#text = str(cell.text()).strip()
#if len(text):
#cell.setStyleSheet("QLineEdit{background: white;}")
#return text, True
#else:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
def on_validate(self):
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.bar_scale = self.bar_scale_edit.value()
old_obj.opacity = self.opacity_edit.value()
old_obj.is_visible = self.checkbox_show.isChecked()
return True
#name_value, flag0 = self.check_name(self.name_edit)
#ox_value, flag1 = self.check_float(self.transparency_edit)
#if flag0 and flag1:
#self.out_data['clicked_ok'] = True
#return True
#return False
def on_apply(self, force=False):
passed = self.on_validate()
if (passed or force) and self.allow_update:
self.win_parent.on_update_geometry_properties(self.out_data)
return passed
def on_cancel(self):
passed = self.on_apply(force=True)
if passed:
self.close()
class NumberBoxPanel(QWidget):
def __init__(self, parent, resoution = "0.0000"):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("NumberBoxPanel" + str(len(parent.findChildren(NumberBoxPanel))))
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(0,0,0,0)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
if resoution != None:
self.numberBox = QLineEdit(self.frameBoxPanel)
self.numberBox.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.numberBox.setFont(font)
self.numberBox.setObjectName(self.objectName() + "_numberBox")
self.numberBox.setText("0.0")
self.numberBox.setMinimumWidth(70)
self.numberBox.setMaximumWidth(70)
self.hLayoutframeBoxPanel.addWidget(self.numberBox)
self.numberBox.textChanged.connect(self.numberBoxChanged)
self.numberBox.editingFinished.connect(self.numberBoxEditingFinished)
else:
self.numberBox = QSpinBox(self.frameBoxPanel)
self.numberBox.setObjectName(self.objectName() + "_numberBox")
self.numberBox.setMinimumWidth(70)
self.numberBox.setMaximumWidth(70)
self.numberBox.setMinimum(-100000000)
self.numberBox.setMaximum(100000000)
self.numberBox.setValue(1)
self.hLayoutframeBoxPanel.addWidget(self.numberBox)
self.imageButton = QPushButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal, QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
spacerItem = QSpacerItem(10,10,QSizePolicy.Expanding, QSizePolicy.Minimum)
self.hLayoutBoxPanel.addItem(spacerItem)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.numberResolution = resoution
str0 = String.Number2String(6.6788, "0.0000")
self.Value = 0
self.captionUnits = ""
def imageButtonClicked(self):
self.emit(SIGNAL("Event_1"), self)
def method_6(self, string_0):
return "%s%s\t%f %s"%(string_0, self.Caption, self.Value, self.CaptionUnits);
def numberBoxEditingFinished(self):
self.emit(SIGNAL("editingFinished"), self)
def numberBoxChanged(self):
try:
test = float(self.numberBox.text())
self.emit(SIGNAL("Event_0"), self)
except:
if self.numberBox.text() == "" or self.numberBox.text() == "-" or self.numberBox.text() == "+":
return
str0 = "You must input the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
self.numberBox.setText("0.0")
def get_CaptionUnits(self):
return self.captionUnits
def set_CaptionUnits(self, captionUnits):
self.captionUnits = captionUnits
CaptionUnits = property(get_CaptionUnits, set_CaptionUnits, None, None)
def get_Caption(self):
caption = self.captionLabel.text()
findIndex = caption.indexOf("(")
if findIndex > 0:
val = caption.left(findIndex)
return val
return caption
def set_Caption(self, captionStr):
if self.CaptionUnits != "" and self.CaptionUnits != None:
self.captionLabel.setText(QString(captionStr + "(") + self.CaptionUnits + QString("):"))
else:
self.captionLabel.setText(captionStr + ":")
Caption = property(get_Caption, set_Caption, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
def get_Value(self):
try:
if self.numberResolution != None:
return float(self.numberBox.text())
else:
return self.numberBox.value()
except:
return 0.0
def set_Value(self, valueFloat):
if self.numberResolution != None:
if valueFloat == None or valueFloat == "":
rStr = String.Number2String(0, self.numberResolution)
self.numberBox.setText(rStr)
return
try:
test = float(valueFloat)
rStr = String.Number2String(test, self.numberResolution)
self.numberBox.setText(rStr)
except:
str0 = "You must put the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
rStr = String.Number2String(0, self.numberResolution)
self.numberBox.setText(rStr)
else:
try:
test = int(valueFloat)
self.numberBox.setValue(test)
except:
str0 = "You must put the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
self.numberBox.setValue(0)
Value = property(get_Value, set_Value, None, None)
# def get_IsEmpty(self):
# return self.numberBox.text() == "" or self.numberBox.text() == None
# IsEmpty = property(get_IsEmpty, None, None, None)
def get_ReadOnly(self):
return self.numberBox.isReadOnly()
def set_ReadOnly(self, bool):
self.numberBox.setReadOnly(bool)
ReadOnly = property(get_ReadOnly, set_ReadOnly, None, None)
def set_LabelWidth(self, width):
self.captionLabel.setMinimumSize(QSize(width, 0))
self.captionLabel.setMaximumSize(QSize(width, 16777215))
LabelWidth = property(None, set_LabelWidth, None, None)
def set_Width(self, width):
self.numberBox.setMinimumSize(QSize(width, 0))
self.numberBox.setMaximumSize(QSize(width, 16777215))
Width = property(None, set_Width, None, None)
def get_Enabled(self):
return self.isEnabled()
def set_Enabled(self, bool):
self.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def set_Button(self, imageName):
if imageName == None or imageName == "":
self.imageButton.setVisible(False)
return
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/" + imageName)), QIcon.Normal, QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setVisible(True)
Button = property(None, set_Button, None, None)
class CompletionSection(QWidget):
def __init__(self):
super(CompletionSection, self).__init__()
EditorConfiguration.install_widget(self.tr("Autocompletado"), self)
container = QVBoxLayout(self)
group_complete = QGroupBox(self.tr("Completar:"))
box = QGridLayout(group_complete)
box.setContentsMargins(20, 5, 20, 5)
self.check_bracket = QCheckBox(self.tr("Corchetes []"))
box.addWidget(self.check_bracket, 0, 0)
self.check_paren = QCheckBox(self.tr("Paréntesis ()"))
box.addWidget(self.check_paren, 0, 1)
self.check_key = QCheckBox(self.tr("Llaves {}"))
box.addWidget(self.check_key, 1, 0)
self.check_quote = QCheckBox(self.tr("Comillas Dobles \" \""))
box.addWidget(self.check_quote, 1, 1)
self.check_single_quote = QCheckBox(self.tr("Comillas Simples ' '"))
box.addWidget(self.check_single_quote, 2, 0)
group_completion = QGroupBox(self.tr("Completado de Código:"))
box = QGridLayout(group_completion)
box.setContentsMargins(20, 5, 20, 5)
self.check_completion = QCheckBox(self.tr("Activar Completado"))
box.addWidget(self.check_completion, 0, 0)
self.check_document = QCheckBox(self.tr("Basado en el código"))
box.addWidget(self.check_document, 0, 1)
self.check_keywords = QCheckBox(self.tr("Palabras Claves"))
box.addWidget(self.check_keywords, 1, 0)
self.check_cs = QCheckBox(
self.tr("Sensitivo a mayúsculas y minúsculas"))
box.addWidget(self.check_cs, 1, 1)
self.check_replace_word = QCheckBox(self.tr("Reemplazar Palabra"))
box.addWidget(self.check_replace_word, 2, 0)
self.check_show_single = QCheckBox(self.tr("Mostrar Simple"))
box.addWidget(self.check_show_single, 2, 1)
hbox = QHBoxLayout()
hbox.addWidget(QLabel(
self.tr("Número de caractéres para mostrar lista:")))
self.spin_threshold = QSpinBox()
self.spin_threshold.setMinimum(1)
self.spin_threshold.setFixedWidth(100)
hbox.addWidget(self.spin_threshold)
box.addLayout(hbox, 3, 0, Qt.AlignLeft)
# Agrupo al contenedor principal
container.addWidget(group_complete)
container.addWidget(group_completion)
container.addItem(QSpacerItem(0, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
self._state_change(self.check_completion.isChecked())
# Conexiones
self.check_completion.stateChanged[int].connect(self._state_change)
# Configuration
self.check_key.setChecked(
settings.get_setting('editor/complete-brace'))
self.check_bracket.setChecked("[" in settings.BRACES)
self.check_paren.setChecked("(" in settings.BRACES)
self.check_quote.setChecked('""' in settings.QUOTES)
#settings.get_setting('editor/complete-double-quote'))
self.check_single_quote.setChecked("''" in settings.QUOTES)
#settings.get_setting('editor/complete-single-quote'))
self.check_completion.setChecked(
settings.get_setting('editor/completion'))
self.spin_threshold.setValue(
settings.get_setting('editor/completion-threshold'))
self.check_keywords.setChecked(
settings.get_setting('editor/completion-keywords'))
self.check_document.setChecked(
settings.get_setting('editor/completion-document'))
self.check_cs.setChecked(
settings.get_setting('editor/completion-cs'))
self.check_replace_word.setChecked(
settings.get_setting('editor/completion-replace-word'))
self.check_show_single.setChecked(
settings.get_setting('editor/completion-single'))
def _state_change(self, value):
state = bool(value)
self.check_document.setEnabled(state)
self.check_keywords.setEnabled(state)
self.check_cs.setEnabled(state)
self.check_replace_word.setEnabled(state)
self.check_show_single.setEnabled(state)
self.spin_threshold.setEnabled(state)
def save(self):
settings.set_setting('editor/complete-brace',
self.check_key.isChecked())
settings.set_setting('editor/complete-bracket',
self.check_bracket.isChecked())
if self.check_bracket.isChecked():
settings.BRACES['['] = ']'
elif ('[') in settings.BRACES:
del settings.BRACES['[']
settings.set_setting('editor/complete-paren',
self.check_paren.isChecked())
if self.check_paren.isChecked():
settings.BRACES['('] = ')'
elif ('(') in settings.BRACES:
del settings.BRACES['(']
settings.set_setting('editor/complete-double-quote',
self.check_quote.isChecked())
if self.check_quote.isChecked():
settings.QUOTES.append('""')
elif '""' in settings.QUOTES:
settings.QUOTES.remove('""')
settings.set_setting('editor/complete-single-quote',
self.check_single_quote.isChecked())
if self.check_single_quote.isChecked():
settings.QUOTES.append('""')
elif "''" in settings.QUOTES:
settings.QUOTES.remove("''")
code_completion = self.check_completion.isChecked()
settings.set_setting('editor/completion',
code_completion)
settings.set_setting('editor/completion-threshold',
self.spin_threshold.value())
settings.set_setting('editor/completion-keywords',
self.check_keywords.isChecked())
settings.set_setting('editor/completion-document',
self.check_document.isChecked())
settings.set_setting('editor/completion-cs',
self.check_cs.isChecked())
settings.set_setting('editor/completion-replace-word',
self.check_replace_word.isChecked())
settings.set_setting('editor/completion-single',
self.check_show_single.isChecked())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.active_code_completion(code_completion)
class GeneralSection(QWidget):
""" Clase Configuracion Editor """
def __init__(self):
super(GeneralSection, self).__init__()
main_container = QVBoxLayout(self)
# Tabs and indentation
group_indentation = QGroupBox(self.tr("Indentación y Tabs:"))
box = QGridLayout(group_indentation)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Política:")), 0, 0)
self.combo_tabs = QComboBox()
self.combo_tabs.setFixedWidth(350)
self.combo_tabs.addItems([
self.tr("Solo Espacios"),
self.tr("Solo Tabulaciones"),
])
box.addWidget(self.combo_tabs, 0, 1)
self.combo_tabs.setCurrentIndex(
int(settings.get_setting('editor/usetabs')))
# Auto indent
self.check_autoindent = QCheckBox(self.tr("Indentación Automática"))
box.addWidget(self.check_autoindent, 1, 0)
box.setAlignment(Qt.AlignLeft)
self.check_autoindent.setChecked(settings.get_setting('editor/indent'))
# Minimap
group_minimap = QGroupBox(self.tr("Minimapa:"))
box = QGridLayout(group_minimap)
box.setContentsMargins(20, 5, 20, 5)
self.check_minimap = QCheckBox(
self.tr("Activar Minimapa (requiere reiniciar el Editor)"))
self.check_minimap.setChecked(settings.get_setting('editor/minimap'))
box.addWidget(self.check_minimap, 0, 0)
#self.check_minimap_animation = QCheckBox(self.tr("Enable animation"))
#self.check_minimap_animation.setChecked(
#settings.get_setting('editor/minimap-animation'))
#box.addWidget(self.check_minimap_animation, 1, 0)
#box.addWidget(QLabel(self.tr("Size Area:")), 2, 0)
#self.spin_area_minimap = QSpinBox()
#self.spin_area_minimap.setFixedWidth(350)
#box.addWidget(self.spin_area_minimap, 2, 1)
box.setAlignment(Qt.AlignLeft)
# Cursor
group_caret = QGroupBox(self.tr("Cursor:"))
box = QGridLayout(group_caret)
box.setContentsMargins(20, 5, 20, 5)
box.setAlignment(Qt.AlignLeft)
# Type
box.addWidget(QLabel(self.tr("Tipo:")), 0, 0)
self.combo_caret = QComboBox()
self.combo_caret.setFixedWidth(300)
caret_types = [
self.tr('Invisible'),
self.tr('Línea'),
self.tr('Bloque')
]
self.combo_caret.addItems(caret_types)
index = settings.get_setting('editor/cursor')
self.combo_caret.setCurrentIndex(index)
box.addWidget(self.combo_caret, 0, 1)
# Width
box.addWidget(QLabel(self.tr("Ancho:")), 1, 0)
self.spin_caret_width = QSpinBox()
self.spin_caret_width.setFixedWidth(300)
if index != 1:
self.spin_caret_width.setEnabled(False)
self.spin_caret_width.setRange(1, 3)
self.spin_caret_width.setValue(
settings.get_setting('editor/caret-width'))
box.addWidget(self.spin_caret_width, 1, 1, Qt.AlignLeft)
# Period
box.addWidget(QLabel(self.tr("Período (ms):")), 2, 0)
self.slider_caret_period = QSlider(Qt.Horizontal)
self.slider_caret_period.setMaximum(500)
self.slider_caret_period.setFixedWidth(300)
box.addWidget(self.slider_caret_period, 2, 1, Qt.AlignLeft)
lcd_caret = QLCDNumber()
lcd_caret.setSegmentStyle(QLCDNumber.Flat)
box.addWidget(lcd_caret, 2, 3)
# Font
group_typo = QGroupBox(self.tr("Fuente:"))
box = QGridLayout(group_typo)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Familia:")), 0, 0)
self.combo_font = QFontComboBox()
self.combo_font.setFixedWidth(350)
box.addWidget(self.combo_font, 0, 1)
self._load_font()
box.addWidget(QLabel(self.tr("Tamaño:")), 1, 0)
self.spin_size_font = QSpinBox()
self.spin_size_font.setValue(settings.get_setting('editor/size-font'))
self.spin_size_font.setFixedWidth(350)
box.addWidget(self.spin_size_font, 1, 1)
box.setAlignment(Qt.AlignLeft)
# Scheme
group_scheme = QGroupBox(self.tr("Tema:"))
box = QVBoxLayout(group_scheme)
box.setContentsMargins(20, 5, 20, 5)
self.combo_scheme = QComboBox()
self.combo_scheme.setFixedWidth(350)
self.combo_scheme.addItems(['Dark Edis', 'White Edis'])
scheme = settings.get_setting('editor/scheme')
index = 0
if scheme != 'dark':
index = 1
self.combo_scheme.setCurrentIndex(index)
box.addWidget(self.combo_scheme)
box.addWidget(QLabel(self.tr("Requiere reiniciar Edis")))
## Agrupación
main_container.addWidget(group_indentation)
main_container.addWidget(group_minimap)
main_container.addWidget(group_caret)
main_container.addWidget(group_typo)
main_container.addWidget(group_scheme)
main_container.addItem(QSpacerItem(0, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding))
EditorConfiguration.install_widget(self.tr("General"), self)
# Conexiones
self.combo_scheme.currentIndexChanged['const QString&'].connect(
self._change_scheme)
self.combo_caret.currentIndexChanged[int].connect(
self._caret_type_changed)
self.slider_caret_period.valueChanged[int].connect(
lcd_caret.display)
self.slider_caret_period.setValue(
settings.get_setting('editor/cursor-period'))
def _change_scheme(self, theme):
theme = theme.split()[0].lower()
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
# Restyle
pass
def _caret_type_changed(self, index):
self.spin_caret_width.setEnabled(bool(index))
def _load_font(self):
font = settings.get_setting('editor/font')
self.combo_font.setCurrentFont(QFont(font))
def save(self):
""" Guarda las configuraciones del Editor. """
use_tabs = bool(self.combo_tabs.currentIndex())
settings.set_setting('editor/usetabs', use_tabs)
auto_indent = self.check_autoindent.isChecked()
settings.set_setting('editor/indent', auto_indent)
settings.set_setting('editor/minimap', self.check_minimap.isChecked())
#settings.set_setting('editor/minimap-animation',
#self.check_minimap_animation.isChecked())
font = self.combo_font.currentFont().family()
settings.set_setting('editor/font', font)
font_size = self.spin_size_font.value()
settings.set_setting('editor/size-font', font_size)
scheme = self.combo_scheme.currentText().split()[0].lower()
settings.set_setting('editor/scheme', scheme)
settings.set_setting('editor/cursor',
self.combo_caret.currentIndex())
settings.set_setting('editor/caret-width',
self.spin_caret_width.value())
settings.set_setting('editor/cursor-period',
self.slider_caret_period.value())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.setIndentationsUseTabs(use_tabs)
editor.load_font(font, font_size)
class EditGeometryProperties(PyDialog):
force = True
def __init__(self, data, win_parent=None):
"""
+------------------+
| Edit Actor Props |
+------------------+------+
| Name1 |
| Name2 |
| Name3 |
| Name4 |
| |
| Active_Name main |
| Color box |
| Line_Width 2 |
| Point_Size 2 |
| Bar_Scale 2 |
| Opacity 0.5 |
| Show/Hide |
| |
| Apply OK Cancel |
+-------------------------+
"""
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
del self.out_data['font_size']
self.setWindowTitle('Edit Geometry Properties')
self.allow_update = True
#default
#self.win_parent = win_parent
#self.out_data = data
self.keys = sorted(data.keys())
self.keys = data.keys()
keys = self.keys
nrows = len(keys)
self.active_key = 'main' #keys[0]
items = keys
header_labels = ['Groups']
table_model = Model(items, header_labels, self)
view = CustomQTableView(self) #Call your custom QTableView here
view.setModel(table_model)
if qt_version == 4:
view.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.table = view
actor_obj = data[self.active_key]
name = actor_obj.name
line_width = actor_obj.line_width
point_size = actor_obj.point_size
bar_scale = actor_obj.bar_scale
opacity = actor_obj.opacity
color = actor_obj.color
show = actor_obj.is_visible
self.representation = actor_obj.representation
# table
header = self.table.horizontalHeader()
header.setStretchLastSection(True)
self._default_is_apply = False
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(name))
self.name_edit.setDisabled(True)
self.color = QLabel("Color:")
self.color_edit = QPushButton()
#self.color_edit.setFlat(True)
color = self.out_data[self.active_key].color
qcolor = QtGui.QColor()
qcolor.setRgb(*color)
#print('color =%s' % str(color))
palette = QtGui.QPalette(
self.color_edit.palette()) # make a copy of the palette
#palette.setColor(QtGui.QPalette.Active, QtGui.QPalette.Base, \
#qcolor)
palette.setColor(QtGui.QPalette.Background,
QtGui.QColor('blue')) # ButtonText
self.color_edit.setPalette(palette)
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" %
tuple(color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.use_slider = True
self.is_opacity_edit_active = False
self.is_opacity_edit_slider_active = False
self.is_line_width_edit_active = False
self.is_line_width_edit_slider_active = False
self.is_point_size_edit_active = False
self.is_point_size_edit_slider_active = False
self.is_bar_scale_edit_active = False
self.is_bar_scale_edit_slider_active = False
self.opacity = QLabel("Opacity:")
self.opacity_edit = QDoubleSpinBox(self)
self.opacity_edit.setRange(0.1, 1.0)
self.opacity_edit.setDecimals(1)
self.opacity_edit.setSingleStep(0.1)
self.opacity_edit.setValue(opacity)
if self.use_slider:
self.opacity_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.opacity_slider_edit.setRange(1, 10)
self.opacity_slider_edit.setValue(opacity * 10)
self.opacity_slider_edit.setTickInterval(1)
self.opacity_slider_edit.setTickPosition(QSlider.TicksBelow)
self.line_width = QLabel("Line Width:")
self.line_width_edit = QSpinBox(self)
self.line_width_edit.setRange(1, 15)
self.line_width_edit.setSingleStep(1)
self.line_width_edit.setValue(line_width)
if self.use_slider:
self.line_width_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.line_width_slider_edit.setRange(1, 15)
self.line_width_slider_edit.setValue(line_width)
self.line_width_slider_edit.setTickInterval(1)
self.line_width_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation in ['point', 'surface']:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
self.line_width_slider_edit.setEnabled(False)
self.point_size = QLabel("Point Size:")
self.point_size_edit = QSpinBox(self)
self.point_size_edit.setRange(1, 15)
self.point_size_edit.setSingleStep(1)
self.point_size_edit.setValue(point_size)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
if self.use_slider:
self.point_size_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.point_size_slider_edit.setRange(1, 15)
self.point_size_slider_edit.setValue(point_size)
self.point_size_slider_edit.setTickInterval(1)
self.point_size_slider_edit.setTickPosition(QSlider.TicksBelow)
self.point_size_slider_edit.setVisible(False)
if self.representation in ['wire', 'surface']:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.bar_scale = QLabel("Bar Scale:")
self.bar_scale_edit = QDoubleSpinBox(self)
#self.bar_scale_edit.setRange(0.01, 1.0) # was 0.1
#self.bar_scale_edit.setRange(0.05, 5.0)
self.bar_scale_edit.setDecimals(1)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
self.bar_scale_edit.setSingleStep(0.1)
self.bar_scale_edit.setValue(bar_scale)
#if self.use_slider:
#self.bar_scale_slider_edit = QSlider(QtCore.Qt.Horizontal)
#self.bar_scale_slider_edit.setRange(1, 100) # 1/0.05 = 100/5.0
#self.bar_scale_slider_edit.setValue(opacity * 0.05)
#self.bar_scale_slider_edit.setTickInterval(10)
#self.bar_scale_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation != 'bar':
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setEnabled(False)
# show/hide
self.checkbox_show = QCheckBox("Show")
self.checkbox_hide = QCheckBox("Hide")
self.checkbox_show.setChecked(show)
self.checkbox_hide.setChecked(not show)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.cancel_button = QPushButton("Close")
self.create_layout()
self.set_connections()
def on_update_geometry_properties_window(self, data):
"""Not Implemented"""
return
#new_keys = sorted(data.keys())
#if self.active_key in new_keys:
#i = new_keys.index(self.active_key)
#else:
#i = 0
#self.table.update_data(new_keys)
#self.out_data = data
#self.update_active_key(i)
def update_active_key(self, index):
"""
Parameters
----------
index : PyQt4.QtCore.QModelIndex
the index of the list
Internal Parameters
-------------------
name : str
the name of obj
obj : CoordProperties, AltGeometry
the storage object for things like line_width, point_size, etc.
"""
if qt_version == 4:
name = str(index.data().toString())
else:
name = str(index.data())
print('name = %r' % name)
#i = self.keys.index(self.active_key)
self.active_key = name
self.name_edit.setText(name)
obj = self.out_data[name]
if isinstance(obj, CoordProperties):
opacity = 1.0
representation = 'coord'
is_visible = obj.is_visible
elif isinstance(obj, AltGeometry):
line_width = obj.line_width
point_size = obj.point_size
bar_scale = obj.bar_scale
opacity = obj.opacity
representation = obj.representation
is_visible = obj.is_visible
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.allow_update = False
self.force = False
self.line_width_edit.setValue(line_width)
self.point_size_edit.setValue(point_size)
self.bar_scale_edit.setValue(bar_scale)
self.force = True
self.allow_update = True
else:
raise NotImplementedError(obj)
allowed_representations = [
'main', 'surface', 'coord', 'toggle', 'wire', 'point', 'bar'
]
if self.representation != representation:
self.representation = representation
if representation not in allowed_representations:
msg = 'name=%r; representation=%r is invalid\nrepresentations=%r' % (
name, representation, allowed_representations)
if self.representation == 'coord':
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
if self.use_slider:
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setVisible(True)
self.color_edit.setVisible(True)
self.line_width.setVisible(True)
self.line_width_edit.setVisible(True)
self.point_size.setVisible(True)
self.point_size_edit.setVisible(True)
self.bar_scale.setVisible(True)
#self.bar_scale_edit.setVisible(True)
self.opacity.setVisible(True)
self.opacity_edit.setVisible(True)
if self.use_slider:
self.opacity_slider_edit.setVisible(True)
self.line_width_slider_edit.setVisible(True)
self.point_size_slider_edit.setVisible(True)
#self.bar_scale_slider_edit.setVisible(True)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
self.line_width.setEnabled(True)
self.line_width_edit.setEnabled(True)
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
show_points = False
show_line_width = True
show_bar_scale = False
if self.use_slider:
self.line_width_slider_edit.setEnabled(True)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setEnabled(True)
self.color_edit.setEnabled(True)
show_points = False
if self.representation in ['point', 'wire+point']:
show_points = True
show_line_width = False
if self.representation in ['wire', 'wire+point', 'bar']:
show_line_width = True
if representation == 'bar':
show_bar_scale = True
else:
show_bar_scale = False
#self.bar_scale_button.setVisible(show_bar_scale)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
#if self.use_slider:
#self.bar_scale_slider_edit.setEnabled(False)
self.point_size.setEnabled(show_points)
self.point_size_edit.setEnabled(show_points)
self.point_size.setVisible(show_points)
self.point_size_edit.setVisible(show_points)
self.line_width.setEnabled(show_line_width)
self.line_width_edit.setEnabled(show_line_width)
self.bar_scale.setEnabled(show_bar_scale)
self.bar_scale_edit.setEnabled(show_bar_scale)
self.bar_scale.setVisible(show_bar_scale)
self.bar_scale_edit.setVisible(show_bar_scale)
if self.use_slider:
self.point_size_slider_edit.setEnabled(show_points)
self.point_size_slider_edit.setVisible(show_points)
self.line_width_slider_edit.setEnabled(show_line_width)
#if self.representation in ['wire', 'surface']:
self.opacity_edit.setValue(opacity)
#if self.use_slider:
#self.opacity_slider_edit.setValue(opacity*10)
self.checkbox_show.setChecked(is_visible)
self.checkbox_hide.setChecked(not is_visible)
passed = self.on_validate()
#self.on_apply(force=True) # TODO: was turned on...do I want this???
#self.allow_update = True
#def on_name_select(self):
#print('on_name_select')
#return
def create_layout(self):
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
grid = QGridLayout()
irow = 0
grid.addWidget(self.name, irow, 0)
grid.addWidget(self.name_edit, irow, 1)
irow += 1
grid.addWidget(self.color, irow, 0)
grid.addWidget(self.color_edit, irow, 1)
irow += 1
grid.addWidget(self.opacity, irow, 0)
if self.use_slider:
grid.addWidget(self.opacity_edit, irow, 2)
grid.addWidget(self.opacity_slider_edit, irow, 1)
else:
grid.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid.addWidget(self.line_width, irow, 0)
if self.use_slider:
grid.addWidget(self.line_width_edit, irow, 2)
grid.addWidget(self.line_width_slider_edit, irow, 1)
else:
grid.addWidget(self.line_width_edit, irow, 1)
irow += 1
grid.addWidget(self.point_size, irow, 0)
if self.use_slider:
grid.addWidget(self.point_size_edit, irow, 2)
grid.addWidget(self.point_size_slider_edit, irow, 1)
else:
grid.addWidget(self.point_size_edit, irow, 1)
irow += 1
grid.addWidget(self.bar_scale, irow, 0)
if self.use_slider and 0:
grid.addWidget(self.bar_scale_edit, irow, 2)
grid.addWidget(self.bar_scale_slider_edit, irow, 1)
else:
grid.addWidget(self.bar_scale_edit, irow, 1)
irow += 1
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
if 0:
vbox.addWidget(self.checkbox_show)
vbox.addWidget(self.checkbox_hide)
else:
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_show)
vbox1.addWidget(self.checkbox_hide)
vbox.addLayout(vbox1)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
self.opacity_edit.valueChanged.connect(self.on_opacity)
self.line_width_edit.valueChanged.connect(self.on_line_width)
self.point_size_edit.valueChanged.connect(self.on_point_size)
self.bar_scale_edit.valueChanged.connect(self.on_bar_scale)
if self.use_slider:
self.opacity_slider_edit.valueChanged.connect(
self.on_opacity_slider)
self.line_width_slider_edit.valueChanged.connect(
self.on_line_width_slider)
self.point_size_slider_edit.valueChanged.connect(
self.on_point_size_slider)
#self.bar_scale_slider_edit.valueChanged.connect(self.on_bar_scale_slider)
# self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'), self.on_opacity)
# self.connect(self.line_width, QtCore.SIGNAL('clicked()'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('clicked()'), self.on_point_size)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
self.color_edit.clicked.connect(self.on_color)
self.checkbox_show.clicked.connect(self.on_show)
self.checkbox_hide.clicked.connect(self.on_hide)
self.cancel_button.clicked.connect(self.on_cancel)
# closeEvent
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def closeEvent(self, event):
self.on_cancel()
def on_color(self):
"""called when the user clicks on the color box"""
name = self.active_key
obj = self.out_data[name]
rgb_color_ints = obj.color
msg = name
col = QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self,
"Choose a %s color" % msg)
if col.isValid():
color_float = col.getRgbF()[:3]
obj.color = color_float
color_int = [int(colori * 255) for colori in color_float]
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(color_int) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.on_apply(force=self.force)
#print(self.allow_update)
def on_show(self):
"""shows the actor"""
name = self.active_key
is_checked = self.checkbox_show.isChecked()
self.out_data[name].is_visible = is_checked
self.on_apply(force=self.force)
def on_hide(self):
"""hides the actor"""
name = self.active_key
is_checked = self.checkbox_hide.isChecked()
self.out_data[name].is_visible = not is_checked
self.on_apply(force=self.force)
def on_line_width(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_active = True
name = self.active_key
line_width = self.line_width_edit.value()
self.out_data[name].line_width = line_width
if not self.is_line_width_edit_slider_active:
if self.use_slider:
self.line_width_slider_edit.setValue(line_width)
self.is_line_width_edit_active = False
self.on_apply(force=self.force)
self.is_line_width_edit_active = False
def on_line_width_slider(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_slider_active = True
#name = self.active_key
line_width = self.line_width_slider_edit.value()
if not self.is_line_width_edit_active:
self.line_width_edit.setValue(line_width)
self.is_line_width_edit_slider_active = False
def on_point_size(self):
"""increases/decreases the point size"""
self.is_point_size_edit_active = True
name = self.active_key
point_size = self.point_size_edit.value()
self.out_data[name].point_size = point_size
if not self.is_point_size_edit_slider_active:
if self.use_slider:
self.point_size_slider_edit.setValue(point_size)
self.is_point_size_edit_active = False
self.on_apply(force=self.force)
self.is_point_size_edit_active = False
def on_point_size_slider(self):
"""increases/decreases the point size"""
self.is_point_size_edit_slider_active = True
name = self.active_key
point_size = self.point_size_slider_edit.value()
if not self.is_point_size_edit_active:
self.point_size_edit.setValue(point_size)
self.is_point_size_edit_slider_active = False
def on_bar_scale(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_active = True
name = self.active_key
float_bar_scale = self.bar_scale_edit.value()
self.out_data[name].bar_scale = float_bar_scale
if not self.is_bar_scale_edit_slider_active:
int_bar_scale = int(round(float_bar_scale * 20, 0))
#if self.use_slider:
#self.bar_scale_slider_edit.setValue(int_bar_scale)
self.is_bar_scale_edit_active = False
self.on_apply(force=self.force)
self.is_bar_scale_edit_active = False
def on_bar_scale_slider(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_slider_active = True
name = self.active_key
int_bar_scale = self.bar_scale_slider_edit.value()
if not self.is_bar_scale_edit_active:
float_bar_scale = int_bar_scale / 20.
self.bar_scale_edit.setValue(float_bar_scale)
self.is_bar_scale_edit_slider_active = False
def on_opacity(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_active = True
name = self.active_key
float_opacity = self.opacity_edit.value()
self.out_data[name].opacity = float_opacity
if not self.is_opacity_edit_slider_active:
int_opacity = int(round(float_opacity * 10, 0))
if self.use_slider:
self.opacity_slider_edit.setValue(int_opacity)
self.is_opacity_edit_active = False
self.on_apply(force=self.force)
self.is_opacity_edit_active = False
def on_opacity_slider(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_slider_active = True
name = self.active_key
int_opacity = self.opacity_slider_edit.value()
if not self.is_opacity_edit_active:
float_opacity = int_opacity / 10.
self.opacity_edit.setValue(float_opacity)
self.is_opacity_edit_slider_active = False
#def on_axis(self, text):
##print(self.combo_axis.itemText())
#self._axis = str(text)
#self.plane.setText('Point on %s? Plane:' % self._axis)
#self.point_a.setText('Point on %s Axis:' % self._axis)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def on_plane(self, text):
#self._plane = str(text)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def _on_float(self, field):
#try:
#eval_float_from_string(field.text())
#field.setStyleSheet("QLineEdit{background: white;}")
#except ValueError:
#field.setStyleSheet("QLineEdit{background: red;}")
#def on_default_name(self):
#self.name_edit.setText(str(self._default_name))
#self.name_edit.setStyleSheet("QLineEdit{background: white;}")
#def check_float(self, cell):
#text = cell.text()
#try:
#value = eval_float_from_string(text)
#cell.setStyleSheet("QLineEdit{background: white;}")
#return value, True
#except ValueError:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
#def check_name(self, cell):
#text = str(cell.text()).strip()
#if len(text):
#cell.setStyleSheet("QLineEdit{background: white;}")
#return text, True
#else:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
def on_validate(self):
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.bar_scale = self.bar_scale_edit.value()
old_obj.opacity = self.opacity_edit.value()
#old_obj.color = self.color_edit
old_obj.is_visible = self.checkbox_show.isChecked()
return True
#name_value, flag0 = self.check_name(self.name_edit)
#ox_value, flag1 = self.check_float(self.transparency_edit)
#if flag0 and flag1:
#self.out_data['clicked_ok'] = True
#return True
#return False
def on_apply(self, force=False):
passed = self.on_validate()
#print("passed=%s force=%s allow=%s" % (passed, force, self.allow_update))
if (passed or force) and self.allow_update and hasattr(
self.win_parent, 'on_update_geometry_properties'):
#print('obj = %s' % self.out_data[self.active_key])
self.win_parent.on_update_geometry_properties(self.out_data,
name=self.active_key)
return passed
def on_cancel(self):
passed = self.on_apply(force=True)
if passed:
self.close()
class CNSViewerWidget(QWidget):
def __init__(self, path_to_df=None, df=None, *args, **kwargs):
super().__init__(*args, **kwargs)
#Apply QThreading to this step for larger cns files.
if df is None:
self.df = read_cns(path_to_df)
else:
self.df = df
self.orig_df = self.df.copy() #Make copy.
# self.df.reset_index(inplace=True)
self.max_rows = 10
self.render_ui()
self.map_events()
self.refresh()
self.jupyter_notebook_widget.pushVariables({
"df": self.df,
"orig_df": self.orig_df,
"viewer": self.df_widget,
"refresh": self.refresh,
"display": self.display
})
def display(self, obj):
try:
html = obj._repr_html_()
except:
html = str(obj)
self.df_widget.setHtml(html)
def render_ui(self):
"""Builds the UI"""
self.tab_widget = QTabWidget()
#Filter Ops tab
self.filter_ops_widget = CNSFilterOpsWidget(columns=self.df.columns)
commands_widget = QWidget()
self.command_label = QLabel("Command:")
self.command_text_area = LNTextEdit()
self.command_text_area.edit.setReadOnly(True)
self.command_show_button = QPushButton("Apply")
self.command_editable_checkbox = QCheckBox("Editable")
self.command_editable_checkbox.setChecked(False)
commands_widget_layout = QGridLayout()
commands_widget_layout.addWidget(self.filter_ops_widget, 0, 0, 2, 2,
Qt.AlignTop)
commands_widget_layout.addWidget(self.command_label, 2, 0, 1, 1,
Qt.AlignLeft | Qt.AlignTop)
commands_widget_layout.addWidget(self.command_text_area, 3, 0, 2, 2,
Qt.AlignTop)
commands_widget_layout.addWidget(self.command_editable_checkbox, 5, 0,
1, 0, Qt.AlignLeft)
commands_widget_layout.addWidget(self.command_show_button, 5, 1, 1, 1,
Qt.AlignRight)
commands_widget.setLayout(commands_widget_layout)
# self.tab_widget.addTab(self.filter_ops_widget, "n00b Mode")
#Commands Tab
self.tab_widget.addTab(commands_widget, "Raw Commands")
ipython_filter_widget = QWidget()
self.jupyter_notebook_widget = QIPythonWidget()
ipython_filter_widget_layout = QVBoxLayout()
ipython_filter_widget_layout.addWidget(self.jupyter_notebook_widget)
ipython_filter_widget.setLayout(ipython_filter_widget_layout)
self.tab_widget.addTab(ipython_filter_widget, "Jupyter Mode")
self.view_combobox = QComboBox()
modes = ["Show First", "Show Last", "All", "Describe", "Filtered"]
for mode in modes:
self.view_combobox.addItem(mode)
self.max_rows_spinbox = QSpinBox()
#Map the change event to refresh the dataframe.
self.max_rows_spinbox.setMinimum(0)
self.max_rows_spinbox.setMaximum(self.df.shape[0])
self.max_rows_spinbox.setValue(self.max_rows)
self.max_rows_spinbox.setSuffix(" rows")
self.refresh_button = QPushButton("Refresh")
self.df_widget = QTextEdit()
self.df_widget.setReadOnly(True)
self.save_button = QPushButton("Save File")
df_layout = QGridLayout()
df_layout.addWidget(self.view_combobox, 0, 0)
df_layout.addWidget(self.max_rows_spinbox, 0, 1)
df_layout.addWidget(self.refresh_button, 0, 2)
df_layout.addWidget(self.df_widget, 1, 0, 4, 10)
layout = QGridLayout()
layout.addWidget(self.tab_widget, 0, 0, 3, 1,
Qt.AlignLeft | Qt.AlignTop)
layout.addLayout(df_layout, 0, 1, 7, 7)
layout.addWidget(self.save_button, 3, 0, 1, 1, Qt.AlignLeft)
self.setLayout(layout)
def map_events(self):
self.refresh_button.clicked.connect(self.refresh)
self.view_combobox.currentIndexChanged.connect(self.toggle_max_rows)
self.command_show_button.clicked.connect(self.exec_command)
self.filter_ops_widget.add_signal.connect(self.add_filter_op)
self.command_editable_checkbox.stateChanged.connect(
self.toggle_command_area)
def toggle_command_area(self):
self.command_text_area.edit.setReadOnly(not (
self.command_editable_checkbox.isChecked()))
def add_filter_op(self):
command = self.filter_ops_widget.get_command_string()
existing_commands = str(
self.command_text_area.edit.toPlainText()).strip()
if existing_commands != "":
command = "\n{}".format(command)
self.command_text_area.edit.appendPlainText(command)
self.filter_ops_widget.reset()
def exec_command(self):
#Reset df to original.
self.df = self.orig_df.copy()
command = str(self.command_text_area.getText())
try:
exec(command)
except Exception as e:
print("Failed to execute!")
print(repr(e))
self.view_combobox.setCurrentIndex(4)
self.refresh()
def toggle_max_rows(self):
mode = str(self.view_combobox.currentText()).lower()
if mode in ["show first", "show last"]:
self.max_rows_spinbox.setEnabled(True)
else:
self.max_rows_spinbox.setEnabled(False)
def refresh(self):
mode = str(self.view_combobox.currentText()).lower()
if mode == "show first":
self.max_rows = self.max_rows_spinbox.value()
self.df_widget.setHtml(self.df.head(n=self.max_rows)._repr_html_())
elif mode == "show last":
self.max_rows = self.max_rows_spinbox.value()
self.df_widget.setHtml(self.df.tail(n=self.max_rows)._repr_html_())
elif mode == "describe":
self.df_widget.setHtml(self.df.describe()._repr_html_())
elif mode == "filtered":
self.df_widget.setHtml(self.df._repr_html_())
else:
self.df_widget.setHtml(self.df._repr_html_())
class MainWindow(QWidget):
def __init__(self):
QMainWindow.__init__(self)
self.resize(500, 300)
self.mainLayout = QHBoxLayout()
self.chooseLayout = QHBoxLayout()
self.layout = QVBoxLayout()
self.pixLayout = QHBoxLayout()
self.thresholdLayout = QHBoxLayout()
self.timeLayout = QHBoxLayout()
self.contoursLayout = QHBoxLayout()
self.setLayout(self.mainLayout)
self.setWindowTitle(
"Image To Gcode V1.0 ----- build By yizheneng [email protected]")
self.imageLabel = QLabel("image")
self.mainLayout.addWidget(self.imageLabel)
self.mainLayout.addLayout(self.layout)
self.mainLayout.setStretchFactor(self.layout, 1)
self.mainLayout.setStretchFactor(self.imageLabel, 3)
self.pixLengthLabel = QLabel(u"像素大小(mm):")
self.pixDoubleSpinBox = QDoubleSpinBox()
self.pixDoubleSpinBox.setValue(1)
self.pixDoubleSpinBox.setDecimals(6)
self.pixLayout.addWidget(self.pixLengthLabel)
self.pixLayout.addWidget(self.pixDoubleSpinBox)
self.thresholdLabel = QLabel(u"阈值:")
self.thresholdSpinBox = QSpinBox()
self.thresholdSpinBox.valueChanged.connect(self.ThresholdValChange)
self.thresholdSpinBox.setMaximum(255)
self.thresholdSpinBox.setValue(120)
self.thresholdLayout.addWidget(self.thresholdLabel)
self.thresholdLayout.addWidget(self.thresholdSpinBox)
self.timeLabel = QLabel(u"灼烧时间:")
self.timeDoubleSpinBox = QDoubleSpinBox()
self.timeDoubleSpinBox.setValue(0.3)
self.timeLayout.addWidget(self.timeLabel)
self.timeLayout.addWidget(self.timeDoubleSpinBox)
self.chooseLabel = QLabel(u"只雕刻轮廓:")
self.chooseBox = QCheckBox()
self.chooseLayout.addWidget(self.chooseLabel)
self.chooseLayout.addWidget(self.chooseBox)
self.chooseBox.stateChanged.connect(self.ChooseValChanged)
self.contoursWidthLabel = QLabel(u"边框宽度")
self.ContoursWidthSpinBox = QSpinBox()
self.ContoursWidthSpinBox.setEnabled(False)
self.ContoursWidthSpinBox.setValue(1)
self.contoursLayout.addWidget(self.contoursWidthLabel)
self.contoursLayout.addWidget(self.ContoursWidthSpinBox)
self.loadImageButton = QPushButton(u"加载图片")
self.loadImageButton.clicked.connect(self.LoadImageButtonClicked)
self.previewButton = QPushButton(u"预览")
self.previewButton.clicked.connect(self.ThresholdValChange)
self.makeCodeButton = QPushButton(u"生成G代码")
self.makeCodeButton.clicked.connect(self.MakeGcode)
self.layout.addLayout(self.pixLayout)
self.layout.addLayout(self.thresholdLayout)
self.layout.addLayout(self.timeLayout)
self.layout.addLayout(self.chooseLayout)
self.layout.addLayout(self.contoursLayout)
self.layout.addWidget(self.loadImageButton)
self.layout.addWidget(self.previewButton)
self.layout.addWidget(self.makeCodeButton)
def LoadImageButtonClicked(self):
self.filePath = QFileDialog.getOpenFileName(self, u"选择图片文件", "",
"Images (*.bmp)")
if self.filePath == "":
QMessageBox.warning(self, u"发生错误", u"没有选择可以识别的文件！！")
return
self.srcImage = QImage(self.filePath)
self.grayImage = QImage(self.srcImage.size(), QImage.Format_Indexed8)
for i in range(256):
self.grayImage.setColor(i, qRgb(i, i, i))
for i in range(self.srcImage.width()):
for j in range(self.srcImage.height()):
temp = qGray(self.srcImage.pixel(i, j))
self.grayImage.setPixel(i, j, temp)
self.srcImage = QImage(self.grayImage)
self.resultImage = QImage(self.grayImage)
self.imageLabel.setPixmap(QPixmap(self.srcImage))
def ChooseValChanged(self):
self.ContoursWidthSpinBox.setEnabled(self.chooseBox.isChecked())
def ThresholdValChange(self):
for i in range(self.srcImage.width()):
for j in range(self.srcImage.height()):
temp = self.srcImage.pixelIndex(i, j)
if (temp >= self.thresholdSpinBox.value()):
self.grayImage.setPixel(i, j, 255)
else:
self.grayImage.setPixel(i, j, 0)
self.resultImage = QImage(self.grayImage)
#如果选中了只雕刻轮廓
if self.chooseBox.isChecked():
img = np.zeros(
(self.grayImage.height(), self.grayImage.width(), 1), np.uint8)
for i in range(self.grayImage.width()):
for j in range(self.grayImage.height()):
img[j, i] = self.grayImage.pixelIndex(i, j)
#提取轮廓
contours = cv.findContours(img, cv.RETR_LIST,
cv.CHAIN_APPROX_SIMPLE)
img = np.zeros(
(self.grayImage.height(), self.grayImage.width(), 1), np.uint8)
cv.drawContours(img, contours[1][:-1], -1, (255, 255, 255),
self.ContoursWidthSpinBox.value())
#转换轮廓到显示界面
for i in range(self.resultImage.width()):
for j in range(self.resultImage.height()):
if img[j, i] == 0:
self.resultImage.setPixel(i, j, 255)
else:
self.resultImage.setPixel(i, j, 0)
self.imageLabel.setPixmap(QPixmap(self.resultImage))
def MakeGcode(self):
path = QFileDialog.getSaveFileName(self, u"选择保存路径", "", " (*.nc)")
if path == "":
QMessageBox.warning(self, u"发生错误", u"路径错误！！")
return
f = open(path, 'w')
f.write("M5\n")
for i in range(self.resultImage.width()):
flag = False
#检测这一行是否有点
for j in range(self.resultImage.height()):
if self.resultImage.pixelIndex(i, j) < 128:
flag = True
break
#如果这一行都没有点则跳过这一行
if flag:
f.write("G0 Y%f\n" % (i * self.pixDoubleSpinBox.value()))
else:
continue
if (i % 2) > 0:
for j in range(self.resultImage.height()):
if self.resultImage.pixelIndex(i, j) < 128:
f.write("G0 X%f\n" %
(j * self.pixDoubleSpinBox.value()))
f.write("M3\n")
f.write("G4 P%f\n" % self.timeDoubleSpinBox.value())
f.write("M5\n")
else:
for j in range(self.resultImage.height())[::-1]:
if self.resultImage.pixelIndex(i, j) < 128:
f.write("G0 X%f\n" %
(j * self.pixDoubleSpinBox.value()))
f.write("M3\n")
f.write("G4 P%f\n" % self.timeDoubleSpinBox.value())
f.write("M5\n")
f.write("M5\n")
f.write("G0 X0 Y0\n")
f.close()
QMessageBox.information(self, u"成功", u"生成G代码文件成功！！")
class Dialog(QDialog):
def __init__(self, mainwindow):
super(Dialog, self).__init__(mainwindow)
self._document = None
layout = QGridLayout()
self.setLayout(layout)
self.versionLabel = QLabel()
self.lilyChooser = lilychooser.LilyChooser()
self.outputLabel = QLabel()
self.outputCombo = QComboBox()
self.resolutionLabel = QLabel()
self.resolutionCombo = QComboBox(editable=True)
self.antialiasLabel = QLabel()
self.antialiasSpin = QSpinBox(minimum=1, maximum=128, value=1)
self.modeLabel = QLabel()
self.modeCombo = QComboBox()
self.englishCheck = QCheckBox()
self.deleteCheck = QCheckBox()
self.commandLineLabel = QLabel()
self.commandLine = QTextEdit(acceptRichText=False)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).setIcon(icons.get("lilypond-run"))
userguide.addButton(self.buttons, "engrave_custom")
self.resolutionCombo.addItems(['100', '200', '300', '600', '1200'])
self.resolutionCombo.setCurrentIndex(2)
self.modeCombo.addItems(['preview', 'publish', 'debug'])
layout.addWidget(self.versionLabel, 0, 0)
layout.addWidget(self.lilyChooser, 0, 1, 1, 3)
layout.addWidget(self.outputLabel, 1, 0)
layout.addWidget(self.outputCombo, 1, 1, 1, 3)
layout.addWidget(self.resolutionLabel, 2, 0)
layout.addWidget(self.resolutionCombo, 2, 1)
layout.addWidget(self.antialiasLabel, 2, 2, Qt.AlignRight)
layout.addWidget(self.antialiasSpin, 2, 3)
layout.addWidget(self.modeLabel, 3, 0)
layout.addWidget(self.modeCombo, 3, 1, 1, 3)
layout.addWidget(self.englishCheck, 4, 0, 1, 4)
layout.addWidget(self.deleteCheck, 5, 0, 1, 4)
layout.addWidget(self.commandLineLabel, 6, 0, 1, 4)
layout.addWidget(self.commandLine, 7, 0, 1, 4)
layout.addWidget(widgets.Separator(), 8, 0, 1, 4)
layout.addWidget(self.buttons, 9, 0, 1, 4)
app.translateUI(self)
qutil.saveDialogSize(self, "engrave/custom/dialog/size", QSize(480, 260))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
model = listmodel.ListModel(formats, display=lambda f: f.title(),
icon=lambda f: icons.file_type(f.type))
self.outputCombo.setModel(model)
s = QSettings()
s.beginGroup("lilypond_settings")
self.englishCheck.setChecked(
s.value("no_translation", False, bool))
self.deleteCheck.setChecked(
s.value("delete_intermediate_files", True, bool))
if s.value("default_output_target", "pdf", type("")) == "svg":
self.outputCombo.setCurrentIndex(3)
app.jobFinished.connect(self.slotJobFinished)
self.outputCombo.currentIndexChanged.connect(self.makeCommandLine)
self.modeCombo.currentIndexChanged.connect(self.makeCommandLine)
self.deleteCheck.toggled.connect(self.makeCommandLine)
self.resolutionCombo.editTextChanged.connect(self.makeCommandLine)
self.antialiasSpin.valueChanged.connect(self.makeCommandLine)
self.makeCommandLine()
panelmanager.manager(mainwindow).layoutcontrol.widget().optionsChanged.connect(self.makeCommandLine)
def translateUI(self):
self.setWindowTitle(app.caption(_("Engrave custom")))
self.versionLabel.setText(_("LilyPond Version:"))
self.outputLabel.setText(_("Output Format:"))
self.resolutionLabel.setText(_("Resolution:"))
self.antialiasLabel.setText(_("Antialias Factor:"))
self.modeLabel.setText(_("Engraving mode:"))
self.modeCombo.setItemText(0, _("Preview"))
self.modeCombo.setItemText(1, _("Publish"))
self.modeCombo.setItemText(2, _("Layout Control"))
self.englishCheck.setText(_("Run LilyPond with English messages"))
self.deleteCheck.setText(_("Delete intermediate output files"))
self.commandLineLabel.setText(_("Command line:"))
self.buttons.button(QDialogButtonBox.Ok).setText(_("Run LilyPond"))
self.outputCombo.update()
def slotJobFinished(self, doc):
if doc == self._document:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
self._document = None
def setDocument(self, doc):
self.lilyChooser.setLilyPondInfo(command.info(doc))
job = jobmanager.job(doc)
if job and job.isRunning() and not jobattributes.get(job).hidden:
self._document = doc
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def makeCommandLine(self):
"""Reads the widgets and builds a command line."""
f = formats[self.outputCombo.currentIndex()]
self.resolutionCombo.setEnabled('resolution' in f.widgets)
self.antialiasSpin.setEnabled('antialias' in f.widgets)
cmd = ["$lilypond"]
if self.modeCombo.currentIndex() == 0: # preview mode
cmd.append('-dpoint-and-click')
elif self.modeCombo.currentIndex() == 1: # publish mode
cmd.append('-dno-point-and-click')
else: # debug mode
args = panelmanager.manager(self.parent()).layoutcontrol.widget().preview_options()
cmd.extend(args)
if self.deleteCheck.isChecked():
cmd.append('-ddelete-intermediate-files')
else:
cmd.append('-dno-delete-intermediate-files')
d = {
'version': self.lilyChooser.lilyPondInfo().version,
'resolution': self.resolutionCombo.currentText(),
'antialias': self.antialiasSpin.value(),
}
cmd.append("$include")
cmd.extend(f.options(d))
cmd.append("$filename")
self.commandLine.setText(' '.join(cmd))
def getJob(self, document):
"""Returns a Job to start."""
filename, includepath = documentinfo.info(document).jobinfo(True)
i = self.lilyChooser.lilyPondInfo()
cmd = []
for t in self.commandLine.toPlainText().split():
if t == '$lilypond':
cmd.append(i.abscommand() or i.command)
elif t == '$filename':
cmd.append(filename)
elif t == '$include':
cmd.extend('-I' + path for path in includepath)
else:
cmd.append(t)
j = job.Job()
j.directory = os.path.dirname(filename)
j.command = cmd
if self.englishCheck.isChecked():
j.environment['LANG'] = 'C'
j.setTitle("{0} {1} [{2}]".format(
os.path.basename(i.command), i.versionString(), document.documentName()))
return j
class ProfileDockWidget(QDockWidget):
"""
DockWidget class to display the profile
"""
closeSignal = pyqtSignal()
def __init__(self, iface, geometry, mntButton=False, zerosButton=False):
"""
Constructor
:param iface: interface
:param width: dock widget geometry
"""
QDockWidget.__init__(self)
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Profile Tool"))
self.__iface = iface
self.__geom = geometry
self.__canvas = self.__iface.mapCanvas()
self.__types = ['PDF', 'PNG'] # ], 'SVG', 'PS']
self.__libs = []
if Qwt5_loaded:
self.__lib = 'Qwt5'
self.__libs.append('Qwt5')
if matplotlib_loaded:
self.__libs.append('Matplotlib')
elif matplotlib_loaded:
self.__lib = 'Matplotlib'
self.__libs.append('Matplotlib')
else:
self.__lib = None
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "No graph lib available (qwt5 or matplotlib)"),
level=QgsMessageBar.CRITICAL, duration=0)
self.__doTracking = False
self.__vline = None
self.__profiles = None
self.__numLines = None
self.__mntPoints = None
self.__marker = None
self.__tabmouseevent = None
if self.__geom is not None:
self.setGeometry(self.__geom)
self.__contentWidget = QWidget()
self.setWidget(self.__contentWidget)
self.__boxLayout = QHBoxLayout()
self.__contentWidget.setLayout(self.__boxLayout)
self.__plotFrame = QFrame()
self.__frameLayout = QHBoxLayout()
self.__plotFrame.setLayout(self.__frameLayout)
self.__printLayout = QHBoxLayout()
self.__printLayout.addWidget(self.__plotFrame)
self.__legendLayout = QVBoxLayout()
self.__printLayout.addLayout(self.__legendLayout)
self.__printWdg = QWidget()
self.__printWdg.setLayout(self.__printLayout)
self.__plotWdg = None
self.__changePlotWidget()
size = QSize(150, 20)
self.__boxLayout.addWidget(self.__printWdg)
self.__vertLayout = QVBoxLayout()
self.__libCombo = QComboBox()
self.__libCombo.setFixedSize(size)
self.__libCombo.addItems(self.__libs)
self.__vertLayout.addWidget(self.__libCombo)
self.__libCombo.currentIndexChanged.connect(self.__setLib)
if mntButton:
self.__displayMnt = False
self.__mntButton = QPushButton(QCoreApplication.translate("VDLTools", "Display MNT"))
self.__mntButton.setFixedSize(size)
self.__mntButton.clicked.connect(self.__mnt)
self.__vertLayout.addWidget(self.__mntButton)
if zerosButton:
self.__displayZeros = False
self.__zerosButton = QPushButton(QCoreApplication.translate("VDLTools", "Display Zeros"))
self.__zerosButton.setFixedSize(size)
self.__zerosButton.clicked.connect(self.__zeros)
self.__vertLayout.addWidget(self.__zerosButton)
else:
self.__displayZeros = True
self.__maxLabel = QLabel("y max")
self.__maxLabel.setFixedSize(size)
self.__vertLayout.addWidget(self.__maxLabel)
self.__maxSpin = QSpinBox()
self.__maxSpin.setFixedSize(size)
self.__maxSpin.setRange(-10000, 10000)
self.__maxSpin.valueChanged.connect(self.__reScalePlot)
self.__vertLayout.addWidget(self.__maxSpin)
self.__vertLayout.insertSpacing(10, 20)
self.__minLabel = QLabel("y min")
self.__minLabel.setFixedSize(size)
self.__vertLayout.addWidget(self.__minLabel)
self.__minSpin = QSpinBox()
self.__minSpin.setFixedSize(size)
self.__minSpin.setRange(-10000, 10000)
self.__minSpin.valueChanged.connect(self.__reScalePlot)
self.__vertLayout.addWidget(self.__minSpin)
self.__vertLayout.insertSpacing(10, 40)
self.__typeCombo = QComboBox()
self.__typeCombo.setFixedSize(size)
self.__typeCombo.addItems(self.__types)
self.__vertLayout.addWidget(self.__typeCombo)
self.__saveButton = QPushButton(QCoreApplication.translate("VDLTools", "Save"))
self.__saveButton.setFixedSize(size)
self.__saveButton.clicked.connect(self.__save)
self.__vertLayout.addWidget(self.__saveButton)
self.__boxLayout.addLayout(self.__vertLayout)
self.__maxSpin.setEnabled(False)
self.__minSpin.setEnabled(False)
self.__colors = []
for cn in QColor.colorNames():
qc = QColor(cn)
val = qc.red() + qc.green() + qc.blue()
if 0 < val < 450:
self.__colors.append(cn)
def mntButton(self):
"""
To get the mnt button instance
:return: mnt button instance
"""
return self.__mntButton
def zerosButton(self):
"""
To get the zeros button instance
:return: zeros button instance
"""
return self.__zerosButton
def displayMnt(self):
"""
To get if we want to display mnt
:return: true or false
"""
return self.__displayMnt
def __mnt(self):
"""
To toggle mnt display choice
"""
if self.__displayMnt:
self.__displayMnt = False
self.__mntButton.setText(QCoreApplication.translate("VDLTools", "Display MNT"))
else:
self.__displayMnt = True
self.__mntButton.setText(QCoreApplication.translate("VDLTools", "Remove MNT"))
def __zeros(self):
"""
To toggle if we want to display zero elevations or not
"""
if self.__displayZeros:
self.__displayZeros = False
self.__zerosButton.setText(QCoreApplication.translate("VDLTools", "Display Zeros"))
else:
self.__displayZeros = True
self.__zerosButton.setText(QCoreApplication.translate("VDLTools", "Remove Zeros"))
def __changePlotWidget(self):
"""
When plot widget is change (qwt <-> matplotlib)
"""
self.__activateMouseTracking(False)
while self.__frameLayout.count():
child = self.__frameLayout.takeAt(0)
child.widget().deleteLater()
self.__plotWdg = None
if self.__lib == 'Qwt5':
self.__plotWdg = QwtPlot(self.__plotFrame)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(10)
sizePolicy.setVerticalStretch(0)
self.__plotWdg.setSizePolicy(sizePolicy)
self.__plotWdg.setAutoFillBackground(False)
# Decoration
self.__plotWdg.setCanvasBackground(Qt.white)
self.__plotWdg.plotLayout().setAlignCanvasToScales(False)
self.__plotWdg.plotLayout().setSpacing(100)
self.__plotWdg.plotLayout().setCanvasMargin(10, QwtPlot.xBottom)
self.__plotWdg.plotLayout().setCanvasMargin(10, QwtPlot.yLeft)
title = QwtText(QCoreApplication.translate("VDLTools", "Distance [m]"))
title.setFont(QFont("Helvetica", 10))
self.__plotWdg.setAxisTitle(QwtPlot.xBottom, title)
title.setText(QCoreApplication.translate("VDLTools", "Elevation [m]"))
title.setFont(QFont("Helvetica", 10))
self.__plotWdg.setAxisTitle(QwtPlot.yLeft, title)
self.__zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft, QwtPicker.DragSelection, QwtPicker.AlwaysOff,
self.__plotWdg.canvas())
self.__zoomer.setRubberBandPen(QPen(Qt.blue))
grid = QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(self.__plotWdg)
self.__frameLayout.addWidget(self.__plotWdg)
elif self.__lib == 'Matplotlib':
fig = Figure((1.0, 1.0), linewidth=0.0, subplotpars=SubplotParams(left=0, bottom=0, right=1, top=1,
wspace=0, hspace=0))
font = {'family': 'arial', 'weight': 'normal', 'size': 12}
rc('font', **font)
rect = fig.patch
rect.set_facecolor((0.9, 0.9, 0.9))
self.__axes = fig.add_axes((0.07, 0.16, 0.92, 0.82))
self.__axes.set_xbound(0, 1000)
self.__axes.set_ybound(0, 1000)
self.__manageMatplotlibAxe(self.__axes)
self.__plotWdg = FigureCanvasQTAgg(fig)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
self.__plotWdg.setSizePolicy(sizePolicy)
self.__frameLayout.addWidget(self.__plotWdg)
def setProfiles(self, profiles, numLines):
"""
To set the profiles
:param profiles: profiles : positions with elevations (for line and points)
:param numLines: number of selected connected lines
"""
self.__numLines = numLines
self.__profiles = profiles
if self.__lib == 'Matplotlib':
self.__prepare_points()
def __getLinearPoints(self):
"""
To extract the linear points of the profile
"""
profileLen = 0
self.__profiles[0]['l'] = profileLen
for i in range(0, len(self.__profiles)-1):
x1 = float(self.__profiles[i]['x'])
y1 = float(self.__profiles[i]['y'])
x2 = float(self.__profiles[i+1]['x'])
y2 = float(self.__profiles[i+1]['y'])
profileLen += sqrt(((x2-x1)*(x2-x1)) + ((y2-y1)*(y2-y1)))
self.__profiles[i+1]['l'] = profileLen
def __getMnt(self, settings):
"""
To get the MN data for the profile
:param settings: settings containing MN url
"""
if settings is None or settings.mntUrl is None or settings.mntUrl == "None":
url = 'https://map.lausanne.ch/prod/wsgi/profile.json'
elif settings.mntUrl == "":
return
else:
url = settings.mntUrl
names = ['MNT', 'MNS', 'Rocher (approx.)']
data = "layers=MNT%2CMNS%2CRocher%20(approx.)&geom=%7B%22type%22%3A%22LineString%22%2C%22coordinates%22%3A%5B"
pos = 0
for i in range(len(self.__profiles)):
if pos > 0:
data += "%2C"
pos += 1
data += "%5B" + str(self.__profiles[i]['x']) + "%2C" + str(self.__profiles[i]['y']) + "%5D"
data += "%5D%7D&nbPoints=" + str(int(self.__profiles[len(self.__profiles)-1]['l']+1))
try:
response = requests.post(url, data=data)
j = response.text
j_obj = json.loads(j)
profile = j_obj['profile']
self.__mntPoints = []
self.__mntPoints.append(names)
mnt_l = []
mnt_z = []
for p in range(len(names)):
z = []
mnt_z.append(z)
for pt in profile:
mnt_l.append(float(pt['dist']))
values = pt['values']
for p in range(len(names)):
if names[p] in values:
mnt_z[p].append(float(values[names[p]]))
else:
mnt_z[p].append(None)
self.__mntPoints.append(mnt_l)
self.__mntPoints.append(mnt_z)
except HTTPError as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "HTTP Error"),
QCoreApplication.translate("VDLTools", "status error") + "[" + str(e.code) + "] : " + e.reason,
level=QgsMessageBar.CRITICAL, duration=0)
except URLError as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "URL Error"),
e.reason, level=QgsMessageBar.CRITICAL, duration=0)
except ValueError as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "No MNT values here"),
level=QgsMessageBar.CRITICAL, duration=0)
def attachCurves(self, names, settings, usedMnts):
"""
To attach the curves for the layers to the profile
:param names: layers names
"""
if (self.__profiles is None) or (self.__profiles == 0):
return
self.__getLinearPoints()
if usedMnts is not None and (usedMnts[0] or usedMnts[1] or usedMnts[2]):
self.__getMnt(settings)
c = 0
if self.__mntPoints is not None:
for p in range(len(self.__mntPoints[0])):
if usedMnts[p]:
legend = QLabel("<font color='" + self.__colors[c] + "'>" + self.__mntPoints[0][p]
+ "</font>")
self.__legendLayout.addWidget(legend)
if self.__lib == 'Qwt5':
xx = [list(g) for k, g in itertools.groupby(self.__mntPoints[1],
lambda x: x is None) if not k]
yy = [list(g) for k, g in itertools.groupby(self.__mntPoints[2][p], lambda x: x is None)
if not k]
for j in range(len(xx)):
curve = QwtPlotCurve(self.__mntPoints[0][p])
curve.setData(xx[j], yy[j])
curve.setPen(QPen(QColor(self.__colors[c]), 3))
curve.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
qcol = QColor(self.__colors[c])
self.__plotWdg.figure.get_axes()[0].plot(self.__mntPoints[1], self.__mntPoints[2][p],
gid=self.__mntPoints[0][p], linewidth=3)
tmp = self.__plotWdg.figure.get_axes()[0].get_lines()
for t in range(len(tmp)):
if self.__mntPoints[0][p] == tmp[t].get_gid():
tmp[c].set_color((old_div(qcol.red(), 255.0), old_div(qcol.green(), 255.0),
old_div(qcol.blue(), 255.0), old_div(qcol.alpha(), 255.0)))
self.__plotWdg.draw()
break
c += 1
if 'z' in self.__profiles[0]:
for i in range(len(self.__profiles[0]['z'])):
if i < self.__numLines:
v = 0
else:
v = i - self.__numLines + 1
name = names[v]
xx = []
yy = []
for prof in self.__profiles:
xx.append(prof['l'])
yy.append(prof['z'][i])
for j in range(len(yy)):
if yy[j] is None:
xx[j] = None
if i == 0 or i > (self.__numLines-1):
legend = QLabel("<font color='" + self.__colors[c] + "'>" + name + "</font>")
self.__legendLayout.addWidget(legend)
if self.__lib == 'Qwt5':
# Split xx and yy into single lines at None values
xx = [list(g) for k, g in itertools.groupby(xx, lambda x: x is None) if not k]
yy = [list(g) for k, g in itertools.groupby(yy, lambda x: x is None) if not k]
# Create & attach one QwtPlotCurve per one single line
for j in range(len(xx)):
curve = QwtPlotCurve(name)
curve.setData(xx[j], yy[j])
curve.setPen(QPen(QColor(self.__colors[c]), 3))
if i > (self.__numLines-1):
curve.setStyle(QwtPlotCurve.Dots)
pen = QPen(QColor(self.__colors[c]), 8)
pen.setCapStyle(Qt.RoundCap)
curve.setPen(pen)
curve.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
qcol = QColor(self.__colors[c])
if i < self.__numLines:
self.__plotWdg.figure.get_axes()[0].plot(xx, yy, gid=name, linewidth=3)
else:
self.__plotWdg.figure.get_axes()[0].plot(xx, yy, gid=name, linewidth=5, marker='o',
linestyle='None')
tmp = self.__plotWdg.figure.get_axes()[0].get_lines()
for t in range(len(tmp)):
if name == tmp[t].get_gid():
tmp[c].set_color((old_div(qcol.red(), 255.0), old_div(qcol.green(), 255.0),
old_div(qcol.blue(), 255.0), old_div(qcol.alpha(), 255.0)))
self.__plotWdg.draw()
break
c += 1
# scaling this
try:
self.__reScalePlot(None, True)
except:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Rescale problem... (trace printed)"),
level=QgsMessageBar.CRITICAL, duration=0)
print(sys.exc_info()[0], traceback.format_exc())
if self.__lib == 'Qwt5':
self.__plotWdg.replot()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].redraw_in_frame()
self.__plotWdg.draw()
self.__activateMouseTracking(True)
self.__marker.show()
def __reScalePlot(self, value=None, auto=False):
"""
To rescale the profile plot depending to the bounds
:param value: juste because connections give value
:param auto: if automatic ranges calcul is wanted
"""
if (self.__profiles is None) or (self.__profiles == 0):
self.__plotWdg.replot()
return
maxi = 0
for i in range(len(self.__profiles)):
if (ceil(self.__profiles[i]['l'])) > maxi:
maxi = ceil(self.__profiles[i]['l'])
if self.__lib == 'Qwt5':
self.__plotWdg.setAxisScale(2, 0, maxi, 0)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].set_xbound(0, maxi)
minimumValue = self.__minSpin.value()
maximumValue = self.__maxSpin.value()
# to set max y and min y displayed
if auto:
minimumValue = 1000000000
maximumValue = -1000000000
for i in range(len(self.__profiles)):
if 'z' in self.__profiles[i]:
mini = self.__minTab(self.__profiles[i]['z'])
if (mini > 0 or self.__displayZeros) and mini < minimumValue:
minimumValue = ceil(mini) - 1
maxi = self.__maxTab(self.__profiles[i]['z'])
if maxi > maximumValue:
maximumValue = floor(maxi) + 1
if self.__mntPoints is not None:
for pts in self.__mntPoints[2]:
miniMnt = self.__minTab(pts)
if (miniMnt > 0 or self.__displayZeros) and miniMnt < minimumValue:
minimumValue = ceil(miniMnt) - 1
maxiMnt = self.__maxTab(pts)
if maxiMnt > maximumValue:
maximumValue = floor(maxiMnt) + 1
self.__maxSpin.setValue(maximumValue)
self.__minSpin.setValue(minimumValue)
self.__maxSpin.setEnabled(True)
self.__minSpin.setEnabled(True)
if self.__lib == 'Qwt5':
rect = QRectF(0, minimumValue, maxi, maximumValue-minimumValue)
self.__zoomer.setZoomBase(rect)
# to draw vertical lines
for i in range(len(self.__profiles)):
zz = []
for j in range(self.__numLines):
if self.__profiles[i]['z'][j] is not None:
zz.append(j)
color = None
if len(zz) == 2:
width = 3
color = QColor('red')
else:
width = 1
if self.__lib == 'Qwt5':
vertLine = QwtPlotMarker()
vertLine.setLineStyle(QwtPlotMarker.VLine)
pen = vertLine.linePen()
pen.setWidth(width)
if color is not None:
pen.setColor(color)
vertLine.setLinePen(pen)
vertLine.setXValue(self.__profiles[i]['l'])
label = vertLine.label()
label.setText(str(i))
vertLine.setLabel(label)
vertLine.setLabelAlignment(Qt.AlignLeft)
vertLine.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].vlines(self.__profiles[i]['l'], minimumValue, maximumValue,
linewidth=width)
if minimumValue < maximumValue:
if self.__lib == 'Qwt5':
self.__plotWdg.setAxisScale(0, minimumValue, maximumValue, 0)
self.__plotWdg.replot()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].set_ybound(minimumValue, maximumValue)
self.__plotWdg.figure.get_axes()[0].redraw_in_frame()
self.__plotWdg.draw()
@staticmethod
def __minTab(tab):
"""
To get the minimum value in a table
:param tab: table to scan
:return: minimum value
"""
mini = 1000000000
for t in tab:
if t is None:
continue
if t < mini:
mini = t
return mini
@staticmethod
def __maxTab(tab):
"""
To get the maximum value in a table
:param tab: table to scan
:return: maximum value
"""
maxi = -1000000000
for t in tab:
if t is None:
continue
if t > maxi:
maxi = t
return maxi
def __setLib(self):
"""
To set the new widget library (qwt <-> matplotlib)
"""
self.__lib = self.__libs[self.__libCombo.currentIndex()]
self.__changePlotWidget()
def __save(self):
"""
To save the profile in a file, on selected format
"""
idx = self.__typeCombo.currentIndex()
if idx == 0:
self.__outPDF()
elif idx == 1:
self.__outPNG()
else:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Invalid index ") + str(idx),
level=QgsMessageBar.CRITICAL, duration=0)
def __outPDF(self):
"""
To save the profile as pdf file
"""
fileName = QFileDialog.getSaveFileName(
self.__iface.mainWindow(), QCoreApplication.translate("VDLTools", "Save As"),
QCoreApplication.translate("VDLTools", "Profile.pdf"),"Portable Document Format (*.pdf)")
if fileName is not None:
if self.__lib == 'Qwt5':
printer = QPrinter()
printer.setCreator(QCoreApplication.translate("VDLTools", "QGIS Profile Plugin"))
printer.setOutputFileName(fileName)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOrientation(QPrinter.Landscape)
self.__plotWdg.print_(printer)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.savefig(str(fileName))
def __outPNG(self):
"""
To save the profile as png file
"""
fileName = QFileDialog.getSaveFileName(
self.__iface.mainWindow(), QCoreApplication.translate("VDLTools", "Save As"),
QCoreApplication.translate("VDLTools", "Profile.png"),"Portable Network Graphics (*.png)")
if fileName is not None:
QPixmap.grabWidget(self.__printWdg).save(fileName, "PNG")
def clearData(self):
"""
To clear the displayed data
"""
if self.__profiles is None:
return
if self.__lib == 'Qwt5':
self.__plotWdg.clear()
self.__profiles = None
temp1 = self.__plotWdg.itemList()
for j in range(len(temp1)):
if temp1[j].rtti() == QwtPlotItem.Rtti_PlotCurve:
temp1[j].detach()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].cla()
self.__manageMatplotlibAxe(self.__plotWdg.figure.get_axes()[0])
self.__maxSpin.setEnabled(False)
self.__minSpin.setEnabled(False)
self.__maxSpin.setValue(0)
self.__minSpin.setValue(0)
# clear legend
while self.__legendLayout.count():
child = self.__legendLayout.takeAt(0)
child.widget().deleteLater()
def __manageMatplotlibAxe(self, axe):
"""
To manage the axes for matplotlib library
:param axe: the axes element
"""
axe.grid()
axe.tick_params(axis="both", which="major", direction="out", length=10, width=1, bottom=True, top=False,
left=True, right=False)
axe.minorticks_on()
axe.tick_params(axis="both", which="minor", direction="out", length=5, width=1, bottom=True, top=False,
left=True, right=False)
axe.set_xlabel(QCoreApplication.translate("VDLTools", "Distance [m]"))
axe.set_ylabel(QCoreApplication.translate("VDLTools", "Elevation [m]"))
def __activateMouseTracking(self, activate):
"""
To (de)activate the mouse tracking on the profile for matplotlib library
:param activate: true to activate, false to deactivate
"""
if activate:
self.__doTracking = True
self.__loadRubber()
self.cid = self.__plotWdg.mpl_connect('motion_notify_event', self.__mouseevent_mpl)
elif self.__doTracking:
self.__doTracking = False
self.__plotWdg.mpl_disconnect(self.cid)
if self.__marker is not None:
self.__canvas.scene().removeItem(self.__marker)
try:
if self.__vline is not None:
self.__plotWdg.figure.get_axes()[0].lines.remove(self.__vline)
self.__plotWdg.draw()
except Exception as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Tracking exception : ") + str(e),
level=QgsMessageBar.CRITICAL, duration=0)
def __mouseevent_mpl(self, event):
"""
To manage matplotlib mouse tracking event
:param event: mouse tracking event
"""
if event.xdata is not None:
try:
if self.__vline is not None:
self.__plotWdg.figure.get_axes()[0].lines.remove(self.__vline)
except Exception as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Mouse event exception : ") + str(e),
level=QgsMessageBar.CRITICAL, duration=0)
xdata = float(event.xdata)
self.__vline = self.__plotWdg.figure.get_axes()[0].axvline(xdata, linewidth=2, color='k')
self.__plotWdg.draw()
i = 1
while i < len(self.__tabmouseevent)-1 and xdata > self.__tabmouseevent[i][0]:
i += 1
i -= 1
x = self.__tabmouseevent[i][1] + (self.__tabmouseevent[i + 1][1] - self.__tabmouseevent[i][1]) / (
self.__tabmouseevent[i + 1][0] - self.__tabmouseevent[i][0]) * (xdata - self.__tabmouseevent[i][0])
y = self.__tabmouseevent[i][2] + (self.__tabmouseevent[i + 1][2] - self.__tabmouseevent[i][2]) / (
self.__tabmouseevent[i + 1][0] - self.__tabmouseevent[i][0]) * (xdata - self.__tabmouseevent[i][0])
self.__marker.show()
self.__marker.setCenter(QgsPoint(x, y))
def __loadRubber(self):
"""
To load te rubber band for mouse tracking on map
"""
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setIconSize(5)
self.__marker.setIconType(QgsVertexMarker.ICON_BOX)
self.__marker.setPenWidth(3)
def __prepare_points(self):
"""
To prepare the points on map for mouse tracking on profile
"""
self.__tabmouseevent = []
length = 0
for i, point in enumerate(self.__profiles):
if i == 0:
self.__tabmouseevent.append([0, point['x'], point['y']])
else:
length += ((self.__profiles[i]['x'] - self.__profiles[i-1]['x']) ** 2 +
(self.__profiles[i]['y'] - self.__profiles[i-1]['y']) ** 2) ** 0.5
self.__tabmouseevent.append([float(length), float(point['x']), float(point['y'])])
def closeEvent(self, event):
"""
When the dock widget is closed
:param event: close event
"""
if self.__maxSpin is not None:
Signal.safelyDisconnect(self.__maxSpin.valueChanged, self.__reScalePlot)
self.__maxSpin = None
if self.__minSpin is not None:
Signal.safelyDisconnect(self.__minSpin.valueChanged, self.__reScalePlot)
self.__minSpin = None
if self.__saveButton is not None:
Signal.safelyDisconnect(self.__saveButton.clicked, self.__save)
self.__saveButton = None
if self.__libCombo is not None:
Signal.safelyDisconnect(self.__libCombo.currentIndexChanged, self.__setLib)
self.__libCombo = None
self.closeSignal.emit()
if self.__marker is not None:
self.__marker.hide()
QDockWidget.closeEvent(self, event)
class GeneralSection(QWidget):
""" Clase Configuracion Editor """
def __init__(self):
super(GeneralSection, self).__init__()
main_container = QVBoxLayout(self)
# Tabs and indentation
group_indentation = QGroupBox(self.tr("Indentación y Tabs:"))
box = QGridLayout(group_indentation)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Política:")), 0, 0)
self.combo_tabs = QComboBox()
self.combo_tabs.setFixedWidth(350)
self.combo_tabs.addItems([
self.tr("Solo Espacios"),
self.tr("Solo Tabulaciones"),
])
box.addWidget(self.combo_tabs, 0, 1)
self.combo_tabs.setCurrentIndex(
int(settings.get_setting('editor/usetabs')))
# Auto indent
self.check_autoindent = QCheckBox(self.tr("Indentación Automática"))
box.addWidget(self.check_autoindent, 1, 0)
box.setAlignment(Qt.AlignLeft)
self.check_autoindent.setChecked(settings.get_setting('editor/indent'))
# Minimap
group_minimap = QGroupBox(self.tr("Minimapa:"))
box = QGridLayout(group_minimap)
box.setContentsMargins(20, 5, 20, 5)
self.check_minimap = QCheckBox(
self.tr("Activar Minimapa (requiere reiniciar el Editor)"))
self.check_minimap.setChecked(settings.get_setting('editor/minimap'))
box.addWidget(self.check_minimap, 0, 0)
#self.check_minimap_animation = QCheckBox(self.tr("Enable animation"))
#self.check_minimap_animation.setChecked(
#settings.get_setting('editor/minimap-animation'))
#box.addWidget(self.check_minimap_animation, 1, 0)
#box.addWidget(QLabel(self.tr("Size Area:")), 2, 0)
#self.spin_area_minimap = QSpinBox()
#self.spin_area_minimap.setFixedWidth(350)
#box.addWidget(self.spin_area_minimap, 2, 1)
box.setAlignment(Qt.AlignLeft)
# Cursor
group_caret = QGroupBox(self.tr("Cursor:"))
box = QGridLayout(group_caret)
box.setContentsMargins(20, 5, 20, 5)
box.setAlignment(Qt.AlignLeft)
# Type
box.addWidget(QLabel(self.tr("Tipo:")), 0, 0)
self.combo_caret = QComboBox()
self.combo_caret.setFixedWidth(300)
caret_types = [
self.tr('Invisible'),
self.tr('Línea'),
self.tr('Bloque')
]
self.combo_caret.addItems(caret_types)
index = settings.get_setting('editor/cursor')
self.combo_caret.setCurrentIndex(index)
box.addWidget(self.combo_caret, 0, 1)
# Width
box.addWidget(QLabel(self.tr("Ancho:")), 1, 0)
self.spin_caret_width = QSpinBox()
self.spin_caret_width.setFixedWidth(300)
if index != 1:
self.spin_caret_width.setEnabled(False)
self.spin_caret_width.setRange(1, 3)
self.spin_caret_width.setValue(
settings.get_setting('editor/caret-width'))
box.addWidget(self.spin_caret_width, 1, 1, Qt.AlignLeft)
# Period
box.addWidget(QLabel(self.tr("Período (ms):")), 2, 0)
self.slider_caret_period = QSlider(Qt.Horizontal)
self.slider_caret_period.setMaximum(500)
self.slider_caret_period.setFixedWidth(300)
box.addWidget(self.slider_caret_period, 2, 1, Qt.AlignLeft)
lcd_caret = QLCDNumber()
lcd_caret.setSegmentStyle(QLCDNumber.Flat)
box.addWidget(lcd_caret, 2, 3)
# Font
group_typo = QGroupBox(self.tr("Fuente:"))
box = QGridLayout(group_typo)
box.setContentsMargins(20, 5, 20, 5)
box.addWidget(QLabel(self.tr("Familia:")), 0, 0)
self.combo_font = QFontComboBox()
self.combo_font.setFixedWidth(350)
box.addWidget(self.combo_font, 0, 1)
self._load_font()
box.addWidget(QLabel(self.tr("Tamaño:")), 1, 0)
self.spin_size_font = QSpinBox()
self.spin_size_font.setValue(settings.get_setting('editor/size-font'))
self.spin_size_font.setFixedWidth(350)
box.addWidget(self.spin_size_font, 1, 1)
box.setAlignment(Qt.AlignLeft)
# Scheme
group_scheme = QGroupBox(self.tr("Tema:"))
box = QVBoxLayout(group_scheme)
box.setContentsMargins(20, 5, 20, 5)
self.combo_scheme = QComboBox()
self.combo_scheme.setFixedWidth(350)
self.combo_scheme.addItems(['Dark Edis', 'White Edis'])
scheme = settings.get_setting('editor/scheme')
index = 0
if scheme != 'dark':
index = 1
self.combo_scheme.setCurrentIndex(index)
box.addWidget(self.combo_scheme)
box.addWidget(QLabel(self.tr("Requiere reiniciar Edis")))
## Agrupación
main_container.addWidget(group_indentation)
main_container.addWidget(group_minimap)
main_container.addWidget(group_caret)
main_container.addWidget(group_typo)
main_container.addWidget(group_scheme)
main_container.addItem(
QSpacerItem(0, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
EditorConfiguration.install_widget(self.tr("General"), self)
# Conexiones
self.combo_scheme.currentIndexChanged['const QString&'].connect(
self._change_scheme)
self.combo_caret.currentIndexChanged[int].connect(
self._caret_type_changed)
self.slider_caret_period.valueChanged[int].connect(lcd_caret.display)
self.slider_caret_period.setValue(
settings.get_setting('editor/cursor-period'))
def _change_scheme(self, theme):
theme = theme.split()[0].lower()
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
# Restyle
pass
def _caret_type_changed(self, index):
self.spin_caret_width.setEnabled(bool(index))
def _load_font(self):
font = settings.get_setting('editor/font')
self.combo_font.setCurrentFont(QFont(font))
def save(self):
""" Guarda las configuraciones del Editor. """
use_tabs = bool(self.combo_tabs.currentIndex())
settings.set_setting('editor/usetabs', use_tabs)
auto_indent = self.check_autoindent.isChecked()
settings.set_setting('editor/indent', auto_indent)
settings.set_setting('editor/minimap', self.check_minimap.isChecked())
#settings.set_setting('editor/minimap-animation',
#self.check_minimap_animation.isChecked())
font = self.combo_font.currentFont().family()
settings.set_setting('editor/font', font)
font_size = self.spin_size_font.value()
settings.set_setting('editor/size-font', font_size)
scheme = self.combo_scheme.currentText().split()[0].lower()
settings.set_setting('editor/scheme', scheme)
settings.set_setting('editor/cursor', self.combo_caret.currentIndex())
settings.set_setting('editor/caret-width',
self.spin_caret_width.value())
settings.set_setting('editor/cursor-period',
self.slider_caret_period.value())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.setIndentationsUseTabs(use_tabs)
editor.load_font(font, font_size)
def initSettingTab(self):
# ##Setting Tab###
setting_tab = QWidget()
setting_tab_layout = QVBoxLayout()
self.tabWidget.addTab(setting_tab, "Settings")
# Task Box
task_box = QGroupBox()
task_box.setTitle(QString("Task properties"))
task_layout = QGridLayout()
# Name
name = QLabel("Name:")
name_value = QLineEdit()
name_value.setText(self.task.hittypename)
name_value.setEnabled(False)
clickable(name_value).connect(self.enable)
task_layout.addWidget(name, 0, 1)
task_layout.addWidget(name_value, 0, 2, 1, 3)
# Description
description = QLabel("Description:")
description_value = QLineEdit()
description_value.setText(self.task.description)
description_value.setEnabled(False)
clickable(description_value).connect(self.enable)
task_layout.addWidget(description, 1, 1)
task_layout.addWidget(description_value, 1, 2, 1, 3)
# Keywords
keywords = QLabel("Keywords:")
keywords_value = QLineEdit()
keywords_value.setText(','.join(self.task.keywords))
keywords_value.setEnabled(False)
clickable(keywords_value).connect(self.enable)
task_layout.addWidget(keywords, 2, 1)
task_layout.addWidget(keywords_value, 2, 2, 1, 3)
# Qualification
qualification = QLabel("Qualification [%]:")
qualification_value = QSpinBox()
qualification_value.setSuffix('%')
qualification_value.setValue(int(self.task.qualification))
qualification_value.setEnabled(False)
clickable(qualification_value).connect(self.enable)
task_layout.addWidget(qualification, 3, 1)
task_layout.addWidget(qualification_value, 3, 4)
# Assignments
assignments = QLabel("Assignments:")
assignments_value = QSpinBox()
assignments_value.setSuffix('')
assignments_value.setValue(int(self.task.assignments))
assignments_value.setEnabled(False)
clickable(assignments_value).connect(self.enable)
task_layout.addWidget(assignments, 4, 1)
task_layout.addWidget(assignments_value, 4, 4)
# Duration
duration = QLabel("Duration [min]:")
duration_value = QSpinBox()
duration_value.setSuffix('min')
duration_value.setValue(int(self.task.duration))
duration_value.setEnabled(False)
clickable(duration_value).connect(self.enable)
task_layout.addWidget(duration, 5, 1)
task_layout.addWidget(duration_value, 5, 4)
# Reward
reward = QLabel("Reward [0.01$]:")
reward_value = QDoubleSpinBox()
reward_value.setRange(0.01, 0.5)
reward_value.setSingleStep(0.01)
reward_value.setSuffix('$')
reward_value.setValue(self.task.reward)
reward_value.setEnabled(False)
clickable(reward_value).connect(self.enable)
task_layout.addWidget(reward, 6, 1)
task_layout.addWidget(reward_value, 6, 4)
# Lifetime
lifetime = QLabel("Lifetime [d]:")
lifetime_value = QSpinBox()
lifetime_value.setSuffix('d')
lifetime_value.setValue(self.task.lifetime)
lifetime_value.setEnabled(False)
clickable(lifetime_value).connect(self.enable)
task_layout.addWidget(lifetime, 7, 1)
task_layout.addWidget(lifetime_value, 7, 4)
# sandbox
sandbox = QCheckBox("Sandbox")
sandbox.setChecked(self.task.sandbox)
task_layout.addWidget(sandbox, 8, 1)
task_box.setLayout(task_layout)
task_layout.setColumnMinimumWidth(1, 120)
# Image Storage Box
storage_box = QGroupBox()
storage_box.setTitle(QString("Image Storage"))
storage_layout = QGridLayout()
# Host URL
host_url = QLabel("Host-URL:")
host_url_value = QLineEdit()
host_url_value.setText(self.task.host_url)
host_url_value.setEnabled(False)
clickable(host_url_value).connect(self.enable)
# Dropbox Path
dropbox_path = QLabel("Dropbox-Path:")
dropbox_path_value = QLineEdit()
dropbox_path_value.setText(self.task.dropbox_path)
dropbox_path_value.setEnabled(False)
clickable(dropbox_path_value).connect(self.enable)
# Dropbox or S3
usingS3 = QRadioButton("S3")
usingS3.setChecked(self.task.usingS3)
usingS3.setEnabled(False)
usingDropbox = QRadioButton("Dropbox")
usingDropbox.setChecked(self.task.usingDropbox)
storage_layout.addWidget(host_url, 0, 1)
storage_layout.addWidget(host_url_value, 0, 2, 1, 3)
storage_layout.addWidget(dropbox_path, 1, 1)
storage_layout.addWidget(dropbox_path_value, 1, 2, 1, 3)
# Add Layouts
save_button = QPushButton("Save Settings")
setting_tab_layout.addWidget(task_box)
setting_tab_layout.addWidget(storage_box)
setting_tab.setLayout(setting_tab_layout)
save_button.clicked.connect(self.SaveSettings)
storage_layout.addWidget(usingS3, 2, 1)
storage_layout.addWidget(usingDropbox, 3, 1)
storage_layout.addWidget(save_button, 3, 4)
# storage_layout.addStretch(1)
storage_box.setLayout(storage_layout)
class Dialog(QDialog):
def __init__(self, mainwindow):
super(Dialog, self).__init__(mainwindow)
self._document = None
layout = QGridLayout()
self.setLayout(layout)
self.versionLabel = QLabel()
self.lilyChooser = lilychooser.LilyChooser()
self.outputLabel = QLabel()
self.outputCombo = QComboBox()
self.resolutionLabel = QLabel()
self.resolutionCombo = QComboBox(editable=True)
self.antialiasLabel = QLabel()
self.antialiasSpin = QSpinBox(minimum=1, maximum=128, value=1)
self.modeLabel = QLabel()
self.modeCombo = QComboBox()
self.englishCheck = QCheckBox()
self.deleteCheck = QCheckBox()
self.commandLineLabel = QLabel()
self.commandLine = QTextEdit(acceptRichText=False)
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).setIcon(
icons.get("lilypond-run"))
userguide.addButton(self.buttons, "engrave_custom")
self.resolutionCombo.addItems(['100', '200', '300', '600', '1200'])
self.resolutionCombo.setCurrentIndex(2)
self.modeCombo.addItems(['preview', 'publish', 'debug'])
layout.addWidget(self.versionLabel, 0, 0)
layout.addWidget(self.lilyChooser, 0, 1, 1, 3)
layout.addWidget(self.outputLabel, 1, 0)
layout.addWidget(self.outputCombo, 1, 1, 1, 3)
layout.addWidget(self.resolutionLabel, 2, 0)
layout.addWidget(self.resolutionCombo, 2, 1)
layout.addWidget(self.antialiasLabel, 2, 2, Qt.AlignRight)
layout.addWidget(self.antialiasSpin, 2, 3)
layout.addWidget(self.modeLabel, 3, 0)
layout.addWidget(self.modeCombo, 3, 1, 1, 3)
layout.addWidget(self.englishCheck, 4, 0, 1, 4)
layout.addWidget(self.deleteCheck, 5, 0, 1, 4)
layout.addWidget(self.commandLineLabel, 6, 0, 1, 4)
layout.addWidget(self.commandLine, 7, 0, 1, 4)
layout.addWidget(widgets.Separator(), 8, 0, 1, 4)
layout.addWidget(self.buttons, 9, 0, 1, 4)
app.translateUI(self)
qutil.saveDialogSize(self, "engrave/custom/dialog/size",
QSize(480, 260))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
model = listmodel.ListModel(formats,
display=lambda f: f.title(),
icon=lambda f: icons.file_type(f.type))
self.outputCombo.setModel(model)
s = QSettings()
s.beginGroup("lilypond_settings")
self.englishCheck.setChecked(s.value("no_translation", False, bool))
self.deleteCheck.setChecked(
s.value("delete_intermediate_files", True, bool))
if s.value("default_output_target", "pdf", type("")) == "svg":
self.outputCombo.setCurrentIndex(3)
app.jobFinished.connect(self.slotJobFinished)
self.outputCombo.currentIndexChanged.connect(self.makeCommandLine)
self.modeCombo.currentIndexChanged.connect(self.makeCommandLine)
self.deleteCheck.toggled.connect(self.makeCommandLine)
self.resolutionCombo.editTextChanged.connect(self.makeCommandLine)
self.antialiasSpin.valueChanged.connect(self.makeCommandLine)
self.makeCommandLine()
panelmanager.manager(
mainwindow).layoutcontrol.widget().optionsChanged.connect(
self.makeCommandLine)
def translateUI(self):
self.setWindowTitle(app.caption(_("Engrave custom")))
self.versionLabel.setText(_("LilyPond Version:"))
self.outputLabel.setText(_("Output Format:"))
self.resolutionLabel.setText(_("Resolution:"))
self.antialiasLabel.setText(_("Antialias Factor:"))
self.modeLabel.setText(_("Engraving mode:"))
self.modeCombo.setItemText(0, _("Preview"))
self.modeCombo.setItemText(1, _("Publish"))
self.modeCombo.setItemText(2, _("Layout Control"))
self.englishCheck.setText(_("Run LilyPond with English messages"))
self.deleteCheck.setText(_("Delete intermediate output files"))
self.commandLineLabel.setText(_("Command line:"))
self.buttons.button(QDialogButtonBox.Ok).setText(_("Run LilyPond"))
self.outputCombo.update()
def slotJobFinished(self, doc):
if doc == self._document:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
self._document = None
def setDocument(self, doc):
self.lilyChooser.setLilyPondInfo(command.info(doc))
if jobmanager.isRunning(doc):
self._document = doc
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def makeCommandLine(self):
"""Reads the widgets and builds a command line."""
f = formats[self.outputCombo.currentIndex()]
self.resolutionCombo.setEnabled('resolution' in f.widgets)
self.antialiasSpin.setEnabled('antialias' in f.widgets)
cmd = ["$lilypond"]
if self.modeCombo.currentIndex() == 0: # preview mode
cmd.append('-dpoint-and-click')
elif self.modeCombo.currentIndex() == 1: # publish mode
cmd.append('-dno-point-and-click')
else: # debug mode
args = panelmanager.manager(
self.parent()).layoutcontrol.widget().preview_options()
cmd.extend(args)
if self.deleteCheck.isChecked():
cmd.append('-ddelete-intermediate-files')
else:
cmd.append('-dno-delete-intermediate-files')
d = {
'version': self.lilyChooser.lilyPondInfo().version,
'resolution': self.resolutionCombo.currentText(),
'antialias': self.antialiasSpin.value(),
}
cmd.append("$include")
cmd.extend(f.options(d))
cmd.append("$filename")
self.commandLine.setText(' '.join(cmd))
def getJob(self, document):
"""Returns a Job to start."""
filename, includepath = documentinfo.info(document).jobinfo(True)
i = self.lilyChooser.lilyPondInfo()
cmd = []
for t in self.commandLine.toPlainText().split():
if t == '$lilypond':
cmd.append(i.abscommand() or i.command)
elif t == '$filename':
cmd.append(filename)
elif t == '$include':
cmd.extend('-I' + path for path in includepath)
else:
cmd.append(t)
j = job.Job()
j.directory = os.path.dirname(filename)
j.command = cmd
if self.englishCheck.isChecked():
j.environment['LANG'] = 'C'
j.setTitle("{0} {1} [{2}]".format(os.path.basename(i.command),
i.versionString(),
document.documentName()))
return j
class CustomOption(QDialog):
def __init__(self, parent=None):
super(CustomOption, self).__init__(parent)
self.options = {}
self.enable = QCheckBox('Enable custom settings')
self.lblFamily = QLabel('Family:')
self.lblWavelet = QLabel('Wavelet:')
self.lblSignal = QLabel('Extension:')
self.lblLvls = QLabel('Levels:')
self.waveletFamily = QComboBox()
self.wavelet = QComboBox()
self.signalEx = QComboBox()
self.lvls = QSpinBox()
self.lvls.setRange(2, 10)
self.periodic = QCheckBox('Frequency')
self.frequency = QSpinBox()
self.frequency.setMinimum(2)
self.frequency.hide()
self.apply = QPushButton('Apply')
self.cancel = QPushButton('Cancel')
self.layout = QGridLayout()
self.layout.addWidget(self.enable, 0, 0, 1, 2)
self.layout.addWidget(self.lblFamily, 1, 0)
self.layout.addWidget(self.waveletFamily, 1, 1)
self.layout.addWidget(self.lblWavelet, 2, 0)
self.layout.addWidget(self.wavelet, 2, 1)
self.layout.addWidget(self.lblSignal, 3, 0)
self.layout.addWidget(self.signalEx, 3, 1)
self.layout.addWidget(self.lblLvls, 4, 0)
self.layout.addWidget(self.lvls, 4, 1)
self.layout.addWidget(self.periodic, 5, 0)
self.layout.addWidget(self.frequency, 5, 1)
self.layout.addWidget(self.apply, 6, 0)
self.layout.addWidget(self.cancel, 6, 1)
self.layout.setAlignment(Qt.AlignCenter)
self.setLayout(self.layout)
self.initComponents()
self.initActions()
self.updateWavelet()
self.enableDisable()
def initComponents(self):
self.setWindowFlags(Qt.Tool)
self.setWindowTitle('Custom settings')
self.waveletFamily.addItems(pywt.families())
self.signalEx.addItems(pywt.MODES.modes)
self.periodic.clicked.connect(self.showFrequency)
self.options['enable'] = False
self.setStyleSheet('QPushButton {\
color: #333;\
border: 1px solid #555;\
border-radius: 11px;\
padding: 2px;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #888);\
min-width: 80px;}\
QPushButton:hover {\
color: #fff;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #bbb);}\
QPushButton:pressed {\
background: qradialgradient(cx: 0.4, cy: -0.1,\
fx: 0.4, fy: -0.1,\
radius: 1.35, stop: 0 #fff, stop: 1 #ddd);}\
QPushButton:checked {\
background: qradialgradient(cx: 0.4, cy: -0.1,\
fx: 0.4, fy: -0.1,\
radius: 1.35, stop: 0 #fff, stop: 1 #ddd);}\
QComboBox {\
color: #333;\
border: 1px solid #555;\
border-radius: 11px;\
padding: 1px 18px 1px 3px;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #888);\
min-width: 20px;}\
QComboBox:hover {\
color: #fff;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #bbb);}\
QComboBox::down-arrow {\
image: url(' + RES + ICONS + ARROW_DOWN + ');}\
QComboBox::down-arrow:on {\
top: 1px;\
left: 1px;}\
QComboBox::drop-down {\
subcontrol-origin: padding;\
subcontrol-position: top right;\
width: 15px;\
border-left-width: 1px;\
border-left-color: darkgray;\
border-left-style: solid;\
border-top-right-radius: 3px;\
border-bottom-right-radius: 3px;}\
QToolButton {\
color: #333;\
border: 1px solid #555;\
border-radius: 11px;\
padding: 2px;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #888);\
min-width: 20px;}\
QToolButton:hover {\
color: #fff;\
background: qradialgradient(cx: 0.3, cy: -0.4,\
fx: 0.3, fy: -0.4,\
radius: 1.35, stop: 0 #fff, stop: 1 #bbb);}\
QToolButton:pressed {\
background: qradialgradient(cx: 0.4, cy: -0.1,\
fx: 0.4, fy: -0.1,\
radius: 1.35, stop: 0 #fff, stop: 1 #ddd);}\
QToolButton:checked {\
background: qradialgradient(cx: 0.4, cy: -0.1,\
fx: 0.4, fy: -0.1,\
radius: 1.35, stop: 0 #fff, stop: 1 #ddd);}')
def initActions(self):
self.apply.clicked.connect(self.saveOptions)
self.cancel.clicked.connect(self.close)
self.waveletFamily.currentIndexChanged.connect(self.updateWavelet)
self.enable.clicked.connect(self.enableDisable)
def saveOptions(self):
self.options['enable'] = self.enable.isChecked()
self.options['wavelet'] = unicode(self.wavelet.currentText())
self.options['signal'] = unicode(self.signalEx.currentText())
self.options['lvls'] = self.lvls.value()
if self.periodic.isChecked():
self.options['frequency'] = self.frequency.value()
self.close()
def updateWavelet(self):
self.wavelet.clear()
self.wavelet.addItems(pywt.wavelist(self.waveletFamily.currentText()))
def showFrequency(self):
if self.periodic.isChecked():
self.frequency.show()
else:
self.frequency.hide()
def enableDisable(self):
if self.enable.isChecked():
self.waveletFamily.setEnabled(True)
self.wavelet.setEnabled(True)
self.lvls.setEnabled(True)
self.signalEx.setEnabled(True)
else:
self.waveletFamily.setEnabled(False)
self.wavelet.setEnabled(False)
self.lvls.setEnabled(False)
self.signalEx.setEnabled(False)
class QuadStatusBar(QHBoxLayout):
def __init__(self, parent=None ):
QHBoxLayout.__init__(self, parent)
self.setContentsMargins(0,4,0,0)
self.setSpacing(0)
def createQuadViewStatusBar(self, xbackgroundColor, xforegroundColor, ybackgroundColor, yforegroundColor, zbackgroundColor, zforegroundColor, graybackgroundColor, grayforegroundColor):
self.xLabel = QLabel()
self.xLabel.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.addWidget(self.xLabel)
pixmap = QPixmap(25*10, 25*10)
pixmap.fill(xbackgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(xforegroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, "X")
brush = QBrush(xforegroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20,20),Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.xLabel.setPixmap(pixmap)
self.xSpinBox = QSpinBox()
self.xSpinBox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.xSpinBox.setEnabled(False)
self.xSpinBox.setAlignment(Qt.AlignCenter)
self.xSpinBox.setToolTip("xSpinBox")
self.xSpinBox.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.xSpinBox.setMaximumHeight(20)
self.xSpinBox.setMaximum(9999)
font = self.xSpinBox.font()
font.setPixelSize(14)
self.xSpinBox.setFont(font)
self.xSpinBox.setStyleSheet("QSpinBox { color: " + str(xforegroundColor.name()) + "; font: bold; background-color: " + str(xbackgroundColor.name()) + "; border:0;}")
self.addWidget(self.xSpinBox)
self.yLabel = QLabel()
self.yLabel.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.addWidget(self.yLabel)
pixmap = QPixmap(25*10, 25*10)
pixmap.fill(ybackgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(yforegroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, "Y")
brush = QBrush(yforegroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20,20),Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.yLabel.setPixmap(pixmap)
self.ySpinBox = QSpinBox()
self.ySpinBox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.ySpinBox.setEnabled(False)
self.ySpinBox.setAlignment(Qt.AlignCenter)
self.ySpinBox.setToolTip("ySpinBox")
self.ySpinBox.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.ySpinBox.setMaximumHeight(20)
self.ySpinBox.setMaximum(9999)
font = self.ySpinBox.font()
font.setPixelSize(14)
self.ySpinBox.setFont(font)
self.ySpinBox.setStyleSheet("QSpinBox { color: " + str(yforegroundColor.name()) + "; font: bold; background-color: " + str(ybackgroundColor.name()) + "; border:0;}")
self.addWidget(self.ySpinBox)
self.zLabel = QLabel()
self.zLabel.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.addWidget(self.zLabel)
pixmap = QPixmap(25*10, 25*10)
pixmap.fill(zbackgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(zforegroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, "Z")
brush = QBrush(zforegroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20,20),Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.zLabel.setPixmap(pixmap)
self.zSpinBox = QSpinBox()
self.zSpinBox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.zSpinBox.setEnabled(False)
self.zSpinBox.setAlignment(Qt.AlignCenter)
self.zSpinBox.setToolTip("zSpinBox")
self.zSpinBox.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.zSpinBox.setMaximumHeight(20)
self.zSpinBox.setMaximum(9999)
font = self.zSpinBox.font()
font.setPixelSize(14)
self.zSpinBox.setFont(font)
self.zSpinBox.setStyleSheet("QSpinBox { color: " + str(zforegroundColor.name()) + "; font: bold; background-color: " + str(zbackgroundColor.name()) + "; border:0;}")
self.addWidget(self.zSpinBox)
self.addSpacing(4)
self.grayScaleLabel = QLabel()
self.grayScaleLabel.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.addWidget(self.grayScaleLabel)
pixmap = QPixmap(610, 250)
pixmap.fill(graybackgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(grayforegroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25*10-30)
path = QPainterPath()
path.addText(QPointF(50, 25*10-50), font, "Gray")
brush = QBrush(grayforegroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(61,20),Qt.KeepAspectRatio, Qt.SmoothTransformation)
"""
self.grayScaleLabel.setPixmap(pixmap)
self.grayScaleSpinBox = QSpinBox()
self.grayScaleSpinBox.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.grayScaleSpinBox.setEnabled(False)
self.grayScaleSpinBox.setAlignment(Qt.AlignCenter)
self.grayScaleSpinBox.setToolTip("grayscaleSpinBox")
self.grayScaleSpinBox.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.grayScaleSpinBox.setMaximum(255)
self.grayScaleSpinBox.setMaximumHeight(20)
self.grayScaleSpinBox.setMaximum(255)
font = self.grayScaleSpinBox.font()
font.setPixelSize(14)
self.grayScaleSpinBox.setFont(font)
self.grayScaleSpinBox.setStyleSheet("QSpinBox { color: " + str(grayforegroundColor.name()) + "; font: bold; background-color: " + str(graybackgroundColor.name()) + "; border:0;}")
self.addWidget(self.grayScaleSpinBox)
"""
self.addStretch()
self.positionCheckBox = QCheckBox()
self.positionCheckBox.setChecked(True)
self.positionCheckBox.setCheckable(True)
self.positionCheckBox.setText("Position")
self.addWidget(self.positionCheckBox)
self.addSpacing(20)
self.channelLabel = QLabel("Channel:")
self.addWidget(self.channelLabel)
self.channelSpinBox = QSpinBox()
self.addWidget(self.channelSpinBox)
self.addSpacing(20)
self.timeLabel = QLabel("Time:")
self.addWidget(self.timeLabel)
self.timeSpinBox = QSpinBox()
self.addWidget(self.timeSpinBox)
"""
def setGrayScale(self, gray):
self.grayScaleSpinBox.setValue(gray)
"""
def setMouseCoords(self, x, y, z):
self.xSpinBox.setValue(x)
self.ySpinBox.setValue(y)
self.zSpinBox.setValue(z)
class ProfileDockWidget(QDockWidget):
"""
DockWidget class to display the profile
"""
closeSignal = pyqtSignal()
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
QDockWidget.__init__(self)
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Profile Tool"))
self.resize(1024, 400)
self.__iface = iface
self.__canvas = self.__iface.mapCanvas()
self.__types = ['PDF', 'PNG'] # ], 'SVG', 'PS']
self.__libs = []
if Qwt5_loaded:
self.__lib = 'Qwt5'
self.__libs.append('Qwt5')
if matplotlib_loaded:
self.__libs.append('Matplotlib')
elif matplotlib_loaded:
self.__lib = 'Matplotlib'
self.__libs.append('Matplotlib')
else:
self.__lib = None
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "No graph lib available (qwt5 or matplotlib)"),
level=QgsMessageBar.CRITICAL, duration=0)
self.__doTracking = False
self.__vline = None
self.__profiles = None
self.__numLines = None
self.__mntPoints = None
self.__marker = None
self.__tabmouseevent = None
self.__contentWidget = QWidget()
self.setWidget(self.__contentWidget)
self.__boxLayout = QHBoxLayout()
self.__contentWidget.setLayout(self.__boxLayout)
self.__plotFrame = QFrame()
self.__frameLayout = QHBoxLayout()
self.__plotFrame.setLayout(self.__frameLayout)
self.__printLayout = QHBoxLayout()
self.__printLayout.addWidget(self.__plotFrame)
self.__legendLayout = QVBoxLayout()
self.__printLayout.addLayout(self.__legendLayout)
self.__printWdg = QWidget()
self.__printWdg.setLayout(self.__printLayout)
self.__plotWdg = None
self.__changePlotWidget()
size = QSize(150, 20)
self.__boxLayout.addWidget(self.__printWdg)
self.__vertLayout = QVBoxLayout()
self.__libCombo = QComboBox()
self.__libCombo.setFixedSize(size)
self.__libCombo.addItems(self.__libs)
self.__vertLayout.addWidget(self.__libCombo)
self.__libCombo.currentIndexChanged.connect(self.__setLib)
self.__maxLabel = QLabel("y max")
self.__maxLabel.setFixedSize(size)
self.__vertLayout.addWidget(self.__maxLabel)
self.__maxSpin = QSpinBox()
self.__maxSpin.setFixedSize(size)
self.__maxSpin.setRange(-10000, 10000)
self.__maxSpin.valueChanged.connect(self.__reScalePlot)
self.__vertLayout.addWidget(self.__maxSpin)
self.__vertLayout.insertSpacing(10, 20)
self.__minLabel = QLabel("y min")
self.__minLabel.setFixedSize(size)
self.__vertLayout.addWidget(self.__minLabel)
self.__minSpin = QSpinBox()
self.__minSpin.setFixedSize(size)
self.__minSpin.setRange(-10000, 10000)
self.__minSpin.valueChanged.connect(self.__reScalePlot)
self.__vertLayout.addWidget(self.__minSpin)
self.__vertLayout.insertSpacing(10, 40)
self.__typeCombo = QComboBox()
self.__typeCombo.setFixedSize(size)
self.__typeCombo.addItems(self.__types)
self.__vertLayout.addWidget(self.__typeCombo)
self.__saveButton = QPushButton(QCoreApplication.translate("VDLTools", "Save"))
self.__saveButton.setFixedSize(size)
self.__saveButton.clicked.connect(self.__save)
self.__vertLayout.addWidget(self.__saveButton)
self.__boxLayout.addLayout(self.__vertLayout)
self.__maxSpin.setEnabled(False)
self.__minSpin.setEnabled(False)
self.__colors = []
for cn in QColor.colorNames():
qc = QColor(cn)
val = qc.red() + qc.green() + qc.blue()
if 0 < val < 450:
self.__colors.append(cn)
def __changePlotWidget(self):
"""
When plot widget is change (qwt <-> matplotlib)
"""
self.__activateMouseTracking(False)
while self.__frameLayout.count():
child = self.__frameLayout.takeAt(0)
child.widget().deleteLater()
self.__plotWdg = None
if self.__lib == 'Qwt5':
self.__plotWdg = QwtPlot(self.__plotFrame)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(10)
sizePolicy.setVerticalStretch(0)
self.__plotWdg.setSizePolicy(sizePolicy)
self.__plotWdg.setAutoFillBackground(False)
# Decoration
self.__plotWdg.setCanvasBackground(Qt.white)
self.__plotWdg.plotLayout().setAlignCanvasToScales(False)
self.__plotWdg.plotLayout().setSpacing(100)
self.__plotWdg.plotLayout().setCanvasMargin(10, QwtPlot.xBottom)
self.__plotWdg.plotLayout().setCanvasMargin(10, QwtPlot.yLeft)
title = QwtText(QCoreApplication.translate("VDLTools", "Distance [m]"))
title.setFont(QFont("Helvetica", 10))
self.__plotWdg.setAxisTitle(QwtPlot.xBottom, title)
title.setText(QCoreApplication.translate("VDLTools", "Elevation [m]"))
title.setFont(QFont("Helvetica", 10))
self.__plotWdg.setAxisTitle(QwtPlot.yLeft, title)
self.__zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft, QwtPicker.DragSelection, QwtPicker.AlwaysOff,
self.__plotWdg.canvas())
self.__zoomer.setRubberBandPen(QPen(Qt.blue))
grid = QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(self.__plotWdg)
self.__frameLayout.addWidget(self.__plotWdg)
elif self.__lib == 'Matplotlib':
# __plotWdg.figure : matplotlib.figure.Figure
fig = Figure((1.0, 1.0), linewidth=0.0, subplotpars=SubplotParams(left=0, bottom=0, right=1, top=1,
wspace=0, hspace=0))
font = {'family': 'arial', 'weight': 'normal', 'size': 12}
rc('font', **font)
rect = fig.patch
rect.set_facecolor((0.9, 0.9, 0.9))
self.__axes = fig.add_axes((0.07, 0.16, 0.92, 0.82))
self.__axes.set_xbound(0, 1000)
self.__axes.set_ybound(0, 1000)
self.__manageMatplotlibAxe(self.__axes)
self.__plotWdg = FigureCanvasQTAgg(fig)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
self.__plotWdg.setSizePolicy(sizePolicy)
self.__frameLayout.addWidget(self.__plotWdg)
def setProfiles(self, profiles, numLines):
"""
To set the profiles
:param profiles: profiles : positions with elevations (for line and points)
:param numLines: number of selected connected lines
"""
self.__numLines = numLines
self.__profiles = profiles
if self.__lib == 'Matplotlib':
self.__prepare_points()
def __getLinearPoints(self):
"""
To extract the linear points of the profile
"""
profileLen = 0
self.__profiles[0]['l'] = profileLen
for i in range(0, len(self.__profiles)-1):
x1 = float(self.__profiles[i]['x'])
y1 = float(self.__profiles[i]['y'])
x2 = float(self.__profiles[i+1]['x'])
y2 = float(self.__profiles[i+1]['y'])
profileLen += sqrt(((x2-x1)*(x2-x1)) + ((y2-y1)*(y2-y1)))
self.__profiles[i+1]['l'] = profileLen
def __getMnt(self, settings):
"""
To get the MN data for the profile
:param settings: settings containing MN url
"""
if settings is None or settings.mntUrl is None or settings.mntUrl == "None":
url = 'http://map.lausanne.ch/main/wsgi/profile.json'
elif settings.mntUrl == "":
return
else:
url = settings.mntUrl
names = ['mnt', 'mns', 'toit_rocher']
url += '?layers='
pos = 0
for name in names:
if pos > 0:
url += ','
pos += 1
url += name
url += '&geom={"type":"LineString","coordinates":['
pos = 0
for i in range(len(self.__profiles)):
if pos > 0:
url += ','
pos += 1
url += '[' + str(self.__profiles[i]['x']) + ',' + str(self.__profiles[i]['y']) + ']'
url = url + ']}&nbPoints=' + str(int(self.__profiles[len(self.__profiles)-1]['l']))
try:
response = urlopen(url)
j = response.read()
j_obj = json.loads(j)
profile = j_obj['profile']
self.__mntPoints = []
self.__mntPoints.append(names)
mnt_l = []
mnt_z = []
for p in range(len(names)):
z = []
mnt_z.append(z)
for pt in profile:
mnt_l.append(float(pt['dist']))
values = pt['values']
for p in range(len(names)):
if names[p] in values:
mnt_z[p].append(float(values[names[p]]))
else:
mnt_z[p].append(None)
self.__mntPoints.append(mnt_l)
self.__mntPoints.append(mnt_z)
except HTTPError as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "HTTP Error"),
QCoreApplication.translate("VDLTools", "status error [" + str(e.code) + "] : " + e.reason),
level=QgsMessageBar.CRITICAL, duration=0)
except URLError as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "URL Error"),
e.reason, level=QgsMessageBar.CRITICAL, duration=0)
def attachCurves(self, names, settings, usedMnts):
"""
To attach the curves for the layers to the profile
:param names: layers names
"""
if (self.__profiles is None) or (self.__profiles == 0):
return
self.__getLinearPoints()
if usedMnts is not None and (usedMnts[0] or usedMnts[1] or usedMnts[2]):
self.__getMnt(settings)
c = 0
if self.__mntPoints is not None:
for p in range(len(self.__mntPoints[0])):
if usedMnts[p]:
legend = QLabel("<font color='" + self.__colors[c] + "'>" + self.__mntPoints[0][p]
+ "</font>")
self.__legendLayout.addWidget(legend)
if self.__lib == 'Qwt5':
xx = [list(g) for k, g in itertools.groupby(self.__mntPoints[1],
lambda x: x is None) if not k]
yy = [list(g) for k, g in itertools.groupby(self.__mntPoints[2][p], lambda x: x is None)
if not k]
for j in range(len(xx)):
curve = QwtPlotCurve(self.__mntPoints[0][p])
curve.setData(xx[j], yy[j])
curve.setPen(QPen(QColor(self.__colors[c]), 3))
curve.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
qcol = QColor(self.__colors[c])
self.__plotWdg.figure.get_axes()[0].plot(self.__mntPoints[1], self.__mntPoints[2][p],
gid=self.__mntPoints[0][p], linewidth=3)
tmp = self.__plotWdg.figure.get_axes()[0].get_lines()
for t in range(len(tmp)):
if self.__mntPoints[0][p] == tmp[t].get_gid():
tmp[c].set_color((old_div(qcol.red(), 255.0), old_div(qcol.green(), 255.0),
old_div(qcol.blue(), 255.0), old_div(qcol.alpha(), 255.0)))
self.__plotWdg.draw()
break
c += 1
if 'z' in self.__profiles[0]:
for i in range(len(self.__profiles[0]['z'])):
if i < self.__numLines:
v = 0
else:
v = i - self.__numLines + 1
name = names[v]
xx = []
yy = []
for prof in self.__profiles:
xx.append(prof['l'])
yy.append(prof['z'][i])
for j in range(len(yy)):
if yy[j] is None:
xx[j] = None
if i == 0 or i > (self.__numLines-1):
legend = QLabel("<font color='" + self.__colors[c] + "'>" + name + "</font>")
self.__legendLayout.addWidget(legend)
if self.__lib == 'Qwt5':
# Split xx and yy into single lines at None values
xx = [list(g) for k, g in itertools.groupby(xx, lambda x: x is None) if not k]
yy = [list(g) for k, g in itertools.groupby(yy, lambda x: x is None) if not k]
# Create & attach one QwtPlotCurve per one single line
for j in range(len(xx)):
curve = QwtPlotCurve(name)
curve.setData(xx[j], yy[j])
curve.setPen(QPen(QColor(self.__colors[c]), 3))
if i > (self.__numLines-1):
curve.setStyle(QwtPlotCurve.Dots)
pen = QPen(QColor(self.__colors[c]), 8)
pen.setCapStyle(Qt.RoundCap)
curve.setPen(pen)
curve.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
qcol = QColor(self.__colors[c])
if i < self.__numLines:
self.__plotWdg.figure.get_axes()[0].plot(xx, yy, gid=name, linewidth=3)
else:
self.__plotWdg.figure.get_axes()[0].plot(xx, yy, gid=name, linewidth=5, marker='o',
linestyle='None')
tmp = self.__plotWdg.figure.get_axes()[0].get_lines()
for t in range(len(tmp)):
if name == tmp[t].get_gid():
tmp[c].set_color((old_div(qcol.red(), 255.0), old_div(qcol.green(), 255.0),
old_div(qcol.blue(), 255.0), old_div(qcol.alpha(), 255.0)))
self.__plotWdg.draw()
break
c += 1
# scaling this
try:
self.__reScalePlot(None, True)
except:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Rescale problem... (trace printed)"),
level=QgsMessageBar.CRITICAL, duration=0)
print(
QCoreApplication.translate("VDLTools", "rescale problem : "), sys.exc_info()[0], traceback.format_exc())
if self.__lib == 'Qwt5':
self.__plotWdg.replot()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].redraw_in_frame()
self.__plotWdg.draw()
self.__activateMouseTracking(True)
self.__marker.show()
def __reScalePlot(self, value=None, auto=False):
"""
To rescale the profile plot depending to the bounds
"""
if (self.__profiles is None) or (self.__profiles == 0):
self.__plotWdg.replot()
return
maxi = 0
for i in range(len(self.__profiles)):
if (int(self.__profiles[i]['l'])) > maxi:
maxi = int(self.__profiles[i]['l']) + 1
if self.__lib == 'Qwt5':
self.__plotWdg.setAxisScale(2, 0, maxi, 0)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].set_xbound(0, maxi)
minimumValue = self.__minSpin.value()
maximumValue = self.__maxSpin.value()
# to set max y and min y displayed
if auto:
minimumValue = 1000000000
maximumValue = -1000000000
for i in range(len(self.__profiles)):
if 'z' in self.__profiles[i]:
mini = self.__minTab(self.__profiles[i]['z'])
if int(mini) < minimumValue:
minimumValue = int(mini) - 1
maxi = self.__maxTab(self.__profiles[i]['z'])
if int(maxi) > maximumValue:
maximumValue = int(maxi) + 1
if self.__mntPoints is not None:
for pts in self.__mntPoints[2]:
miniMnt = self.__minTab(pts)
if int(miniMnt) < minimumValue:
minimumValue = int(miniMnt) - 1
maxiMnt = self.__maxTab(pts)
if int(maxiMnt) > maximumValue:
maximumValue = int(maxiMnt) + 1
self.__maxSpin.setValue(maximumValue)
self.__minSpin.setValue(minimumValue)
self.__maxSpin.setEnabled(True)
self.__minSpin.setEnabled(True)
if self.__lib == 'Qwt5':
rect = QRectF(0, minimumValue, maxi, maximumValue-minimumValue)
self.__zoomer.setZoomBase(rect)
# to draw vertical lines
for i in range(len(self.__profiles)):
zz = []
for j in range(self.__numLines):
if self.__profiles[i]['z'][j] is not None:
zz.append(j)
color = None
if len(zz) == 2:
width = 3
color = QColor('red')
else:
width = 1
if self.__lib == 'Qwt5':
vertLine = QwtPlotMarker()
vertLine.setLineStyle(QwtPlotMarker.VLine)
pen = vertLine.linePen()
pen.setWidth(width)
if color is not None:
pen.setColor(color)
vertLine.setLinePen(pen)
vertLine.setXValue(self.__profiles[i]['l'])
label = vertLine.label()
label.setText(str(i))
vertLine.setLabel(label)
vertLine.setLabelAlignment(Qt.AlignLeft)
vertLine.attach(self.__plotWdg)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].vlines(self.__profiles[i]['l'], minimumValue, maximumValue,
linewidth=width)
if minimumValue < maximumValue:
if self.__lib == 'Qwt5':
self.__plotWdg.setAxisScale(0, minimumValue, maximumValue, 0)
self.__plotWdg.replot()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].set_ybound(minimumValue, maximumValue)
self.__plotWdg.figure.get_axes()[0].redraw_in_frame()
self.__plotWdg.draw()
@staticmethod
def __minTab(tab):
"""
To get the minimum value in a table
:param tab: table to scan
:return: minimum value
"""
mini = 1000000000
for t in tab:
if t is None:
continue
if t < mini:
mini = t
return mini
@staticmethod
def __maxTab(tab):
"""
To get the maximum value in a table
:param tab: table to scan
:return: maximum value
"""
maxi = -1000000000
for t in tab:
if t is None:
continue
if t > maxi:
maxi = t
return maxi
def __setLib(self):
"""
To set the new widget library (qwt <-> matplotlib)
"""
self.__lib = self.__libs[self.__libCombo.currentIndex()]
self.__changePlotWidget()
def __save(self):
"""
To save the profile in a file, on selected format
"""
idx = self.__typeCombo.currentIndex()
if idx == 0:
self.__outPDF()
elif idx == 1:
self.__outPNG()
else:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Invalid index ") + str(idx),
level=QgsMessageBar.CRITICAL, duration=0)
def __outPDF(self):
"""
To save the profile as pdf file
"""
fileName = QFileDialog.getSaveFileName(
self.__iface.mainWindow(), QCoreApplication.translate("VDLTools", "Save As"),
QCoreApplication.translate("VDLTools", "Profile.pdf"),"Portable Document Format (*.pdf)")
if fileName is not None:
if self.__lib == 'Qwt5':
printer = QPrinter()
printer.setCreator(QCoreApplication.translate("VDLTools", "QGIS Profile Plugin"))
printer.setOutputFileName(fileName)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOrientation(QPrinter.Landscape)
self.__plotWdg.print_(printer)
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.savefig(str(fileName))
# printer = QPrinter()
# printer.setCreator(QCoreApplication.translate("VDLTools", "QGIS Profile Plugin"))
# printer.setOutputFileName(fileName)
# printer.setOutputFormat(QPrinter.PdfFormat)
# printer.setOrientation(QPrinter.Landscape)
# printer.setPaperSize(QSizeF(self.__printWdg.size()), QPrinter.Millimeter)
# printer.setFullPage(True)
# self.__printWdg.render(printer)
def __outPNG(self):
"""
To save the profile as png file
"""
fileName = QFileDialog.getSaveFileName(
self.__iface.mainWindow(), QCoreApplication.translate("VDLTools", "Save As"),
QCoreApplication.translate("VDLTools", "Profile.png"),"Portable Network Graphics (*.png)")
if fileName is not None:
QPixmap.grabWidget(self.__printWdg).save(fileName, "PNG")
def clearData(self):
"""
To clear the displayed data
"""
if self.__profiles is None:
return
if self.__lib == 'Qwt5':
self.__plotWdg.clear()
self.__profiles = None
temp1 = self.__plotWdg.itemList()
for j in range(len(temp1)):
if temp1[j].rtti() == QwtPlotItem.Rtti_PlotCurve:
temp1[j].detach()
elif self.__lib == 'Matplotlib':
self.__plotWdg.figure.get_axes()[0].cla()
self.__manageMatplotlibAxe(self.__plotWdg.figure.get_axes()[0])
self.__maxSpin.setEnabled(False)
self.__minSpin.setEnabled(False)
self.__maxSpin.setValue(0)
self.__minSpin.setValue(0)
# clear legend
while self.__legendLayout.count():
child = self.__legendLayout.takeAt(0)
child.widget().deleteLater()
def __manageMatplotlibAxe(self, axe):
"""
To manage the axes for matplotlib library
:param axe: the axes element
"""
axe.grid()
axe.tick_params(axis="both", which="major", direction="out", length=10, width=1, bottom=True, top=False,
left=True, right=False)
axe.minorticks_on()
axe.tick_params(axis="both", which="minor", direction="out", length=5, width=1, bottom=True, top=False,
left=True, right=False)
axe.set_xlabel(QCoreApplication.translate("VDLTools", "Distance [m]"))
axe.set_ylabel(QCoreApplication.translate("VDLTools", "Elevation [m]"))
def __activateMouseTracking(self, activate):
"""
To (de)activate the mouse tracking on the profile for matplotlib library
:param activate: true to activate, false to deactivate
"""
if activate:
self.__doTracking = True
self.__loadRubber()
self.cid = self.__plotWdg.mpl_connect('motion_notify_event', self.__mouseevent_mpl)
elif self.__doTracking:
self.__doTracking = False
self.__plotWdg.mpl_disconnect(self.cid)
if self.__marker is not None:
self.__canvas.scene().removeItem(self.__marker)
try:
if self.__vline is not None:
self.__plotWdg.figure.get_axes()[0].lines.remove(self.__vline)
self.__plotWdg.draw()
except Exception as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Tracking exception : ") + str(e),
level=QgsMessageBar.CRITICAL, duration=0)
def __mouseevent_mpl(self, event):
"""
To manage matplotlib mouse tracking event
:param event: mouse tracking event
"""
if event.xdata is not None:
try:
if self.__vline is not None:
self.__plotWdg.figure.get_axes()[0].lines.remove(self.__vline)
except Exception as e:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Mouse event exception : ") + str(e),
level=QgsMessageBar.CRITICAL, duration=0)
xdata = float(event.xdata)
self.__vline = self.__plotWdg.figure.get_axes()[0].axvline(xdata, linewidth=2, color='k')
self.__plotWdg.draw()
i = 1
while i < len(self.__tabmouseevent)-1 and xdata > self.__tabmouseevent[i][0]:
i += 1
i -= 1
x = self.__tabmouseevent[i][1] + (self.__tabmouseevent[i + 1][1] - self.__tabmouseevent[i][1]) / (
self.__tabmouseevent[i + 1][0] - self.__tabmouseevent[i][0]) * (xdata - self.__tabmouseevent[i][0])
y = self.__tabmouseevent[i][2] + (self.__tabmouseevent[i + 1][2] - self.__tabmouseevent[i][2]) / (
self.__tabmouseevent[i + 1][0] - self.__tabmouseevent[i][0]) * (xdata - self.__tabmouseevent[i][0])
self.__marker.show()
self.__marker.setCenter(QgsPoint(x, y))
def __loadRubber(self):
"""
To load te rubber band for mouse tracking on map
"""
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setIconSize(5)
self.__marker.setIconType(QgsVertexMarker.ICON_BOX)
self.__marker.setPenWidth(3)
def __prepare_points(self):
"""
To prepare the points on map for mouse tracking on profile
"""
self.__tabmouseevent = []
length = 0
for i, point in enumerate(self.__profiles):
if i == 0:
self.__tabmouseevent.append([0, point['x'], point['y']])
else:
length += ((self.__profiles[i]['x'] - self.__profiles[i-1]['x']) ** 2 +
(self.__profiles[i]['y'] - self.__profiles[i-1]['y']) ** 2) ** 0.5
self.__tabmouseevent.append([float(length), float(point['x']), float(point['y'])])
def closeEvent(self, event):
"""
When the dock widget is closed
:param event: close event
"""
if self.__maxSpin is not None:
Signal.safelyDisconnect(self.__maxSpin.valueChanged, self.__reScalePlot)
self.__maxSpin = None
if self.__minSpin is not None:
Signal.safelyDisconnect(self.__minSpin.valueChanged, self.__reScalePlot)
self.__minSpin = None
if self.__saveButton is not None:
Signal.safelyDisconnect(self.__saveButton.clicked, self.__save)
self.__saveButton = None
if self.__libCombo is not None:
Signal.safelyDisconnect(self.__libCombo.currentIndexChanged, self.__setLib)
self.__libCombo = None
self.closeSignal.emit()
if self.__marker is not None:
self.__marker.hide()
QDockWidget.closeEvent(self, event)
class Dialog(KDialog):
def __init__(self, mainwin):
KDialog.__init__(self, mainwin)
self.jobs = []
self.mainwin = mainwin
self.setButtons(KDialog.ButtonCode(
KDialog.Try | KDialog.Help |
KDialog.Details | KDialog.Reset |
KDialog.Ok | KDialog.Cancel))
self.setButtonIcon(KDialog.Try, KIcon("run-lilypond"))
self.setCaption(i18n("Create blank staff paper"))
self.setHelp("blankpaper")
self.setDefaultButton(KDialog.Ok)
layout = QGridLayout(self.mainWidget())
self.typeChooser = QComboBox()
self.stack = QStackedWidget()
StackFader(self.stack)
paperSettings = QWidget(self)
paperSettings.setLayout(QHBoxLayout())
self.actionChooser = QComboBox(self)
layout.addWidget(self.typeChooser, 0, 1)
layout.addWidget(self.stack, 1, 0, 1, 3)
layout.addWidget(self.actionChooser, 2, 1)
l = QLabel(i18n("Type:"))
l.setBuddy(self.typeChooser)
layout.addWidget(l, 0, 0, Qt.AlignRight)
l = QLabel(i18n("Action:"))
l.setBuddy(self.actionChooser)
layout.addWidget(l, 2, 0, Qt.AlignRight)
# tool tips
self.typeChooser.setToolTip(i18n(
"Choose what kind of empty staves you want to create."))
self.actionChooser.setToolTip(i18n(
"Choose which action happens when clicking \"Ok\"."))
self.setButtonToolTip(KDialog.Try, i18n(
"Preview the empty staff paper."))
self.setButtonToolTip(KDialog.Details, i18n(
"Click to see more settings."))
# paper stuff
paper = QGroupBox(i18n("Paper"))
paperSettings.layout().addWidget(paper)
settings = QGroupBox(i18n("Settings"))
paperSettings.layout().addWidget(settings)
paper.setLayout(QGridLayout())
self.paperSize = QComboBox()
l = QLabel(i18n("Paper size:"))
l.setBuddy(self.paperSize)
paper.layout().addWidget(l, 0, 0, Qt.AlignRight)
paper.layout().addWidget(self.paperSize, 0, 1)
self.paperSize.addItem(i18n("Default"))
self.paperSize.addItems(ly.paperSizes)
self.staffSize = QSpinBox()
l = QLabel(i18n("Staff Size:"))
l.setBuddy(self.staffSize)
paper.layout().addWidget(l, 1, 0, Qt.AlignRight)
paper.layout().addWidget(self.staffSize, 1, 1)
self.staffSize.setRange(8, 40)
self.pageCount = QSpinBox()
l = QLabel(i18n("Page count:"))
l.setBuddy(self.pageCount)
paper.layout().addWidget(l, 2, 0, Qt.AlignRight)
paper.layout().addWidget(self.pageCount, 2, 1)
self.pageCount.setRange(1, 1000)
self.removeTagline = QCheckBox(i18n("Remove default tagline"))
paper.layout().addWidget(self.removeTagline, 3, 0, 1, 2)
settings.setLayout(QGridLayout())
self.barLines = QCheckBox(i18n("Print Bar Lines"))
self.barsPerLine = QSpinBox()
l = QLabel(i18n("Bars per line:"))
l.setBuddy(self.barsPerLine)
settings.layout().addWidget(self.barLines, 0, 0, 1, 2)
settings.layout().addWidget(l, 1, 0, Qt.AlignRight)
settings.layout().addWidget(self.barsPerLine, 1, 1)
self.barsPerLine.setRange(1, 20)
self.pageNumbers = QCheckBox(i18n("Print Page Numbers"))
self.pageNumStart = QSpinBox()
l = QLabel(i18n("Start with:"))
l.setBuddy(self.pageNumStart)
settings.layout().addWidget(self.pageNumbers, 2, 0, 1, 2)
settings.layout().addWidget(l, 3, 0, Qt.AlignRight)
settings.layout().addWidget(self.pageNumStart, 3, 1)
self.barLines.toggled.connect(self.barsPerLine.setEnabled)
self.pageNumbers.toggled.connect(self.pageNumStart.setEnabled)
# types
self.typeWidgets = [
SingleStaff(self),
PianoStaff(self),
OrganStaff(self),
ChoirStaff(self),
CustomStaff(self),
]
for widget in self.typeWidgets:
self.stack.addWidget(widget)
self.typeChooser.addItem(widget.name())
self.typeChooser.currentIndexChanged.connect(lambda index:
self.stack.setCurrentWidget(self.typeWidgets[index]))
self.actors = [
PrintPDF,
SavePDF,
OpenPDF,
CopyToEditor,
]
for actor in self.actors:
self.actionChooser.addItem(actor.name())
self.setDetailsWidget(paperSettings)
# cleanup on exit
mainwin.aboutToClose.connect(self.cleanup)
# buttons
self.resetClicked.connect(self.default)
self.tryClicked.connect(self.showPreview)
self.setInitialSize(QSize(400, 240))
self.default()
self.loadSettings()
def done(self, r):
self.saveSettings()
KDialog.done(self, r)
if r:
self.actors[self.actionChooser.currentIndex()](self)
def default(self):
""" Set everything to default """
self.paperSize.setCurrentIndex(0)
self.staffSize.setValue(22)
self.pageCount.setValue(1)
self.removeTagline.setChecked(False)
self.barLines.setChecked(False)
self.barsPerLine.setValue(4)
self.barsPerLine.setEnabled(False)
self.pageNumbers.setChecked(False)
self.pageNumStart.setValue(1)
self.pageNumStart.setEnabled(False)
self.typeChooser.setCurrentIndex(0)
self.actionChooser.setCurrentIndex(0)
for widget in self.typeWidgets:
widget.default()
def loadSettings(self):
conf = config()
self.removeTagline.setChecked(conf.readEntry("remove tagline", False))
action = conf.readEntry("action", "PrintPDF")
for index, actor in enumerate(self.actors):
if actor.__name__ == action:
self.actionChooser.setCurrentIndex(index)
def saveSettings(self):
conf = config()
conf.writeEntry("remove tagline", self.removeTagline.isChecked())
action = self.actors[self.actionChooser.currentIndex()].__name__
conf.writeEntry("action", action)
def showPreview(self):
self.previewDialog().showPreview(self.ly())
@cacheresult
def previewDialog(self):
return PreviewDialog(self)
def ly(self):
"""
Return the LilyPond document to print the empty staff paper.
"""
staff = self.stack.currentWidget()
output = []
version = lilyPondVersion()
if version:
output.append('\\version "{0}"\n'.format(version))
output.append('#(set-global-staff-size {0})\n'.format(self.staffSize.value()))
# paper section
output.append('\\paper {')
if self.paperSize.currentIndex() > 0:
output.append('#(set-paper-size "{0}")'.format(ly.paperSizes[self.paperSize.currentIndex()-1]))
if self.pageNumbers.isChecked():
output.append('top-margin = 10\\mm')
output.append('first-page-number = #{0}'.format(self.pageNumStart.value()))
output.append('oddHeaderMarkup = \\markup \\fill-line {')
output.append('\\strut')
output.append("\\fromproperty #'page:page-number-string")
output.append('}')
else:
output.append('top-margin = 16\\mm')
output.append('oddHeaderMarkup = ##f')
output.append('evenHeaderMarkup = ##f')
if self.removeTagline.isChecked():
output.append('bottom-margin = 16\\mm')
output.append('oddFooterMarkup = ##f')
else:
output.append('bottom-margin = 10\\mm')
output.append('oddFooterMarkup = \\markup \\abs-fontsize #6 \\fill-line {')
tagline = config().readEntry("tagline",
'\\with-url #"http://www.frescobaldi.org/" FRESCOBALDI.ORG')
output.append('\\sans {{ {0} }}'.format(tagline))
output.append('\\strut')
output.append('}')
output.append('evenFooterMarkup = ##f')
output.append('ragged-last-bottom = ##f')
output.append('ragged-right = ##f')
output.append('}\n')
# music expression
output.append('music = \\repeat unfold {0} {{ % pages'.format(self.pageCount.value()))
output.append('\\repeat unfold {0} {{ % systems'.format(staff.systemCount()))
output.append('\\repeat unfold {0} {{ % bars'.format(
self.barLines.isChecked() and self.barsPerLine.value() or 1))
output.extend(('r1', '\\noBreak', '}', '\\break', '\\noPageBreak', '}', '\\pageBreak', '}\n'))
# get the layout
layout = LayoutContexts()
layout.add("Score", '\\remove "Bar_number_engraver"')
layout.add("Voice", "\\override Rest #'stencil = ##f")
music = staff.music(layout)
layout.addToStaffContexts('\\remove "Time_signature_engraver"')
if not self.barLines.isChecked():
layout.disableBarLines()
# write it out
output.append('\\layout {\nindent = #0')
output.extend(layout.ly())
output.append('}\n')
# score
output.append('\\score {')
output.extend(music)
output.append('}\n')
return ly.indent.indent('\n'.join(output))
def cleanup(self):
for job in self.jobs[:]: # copy
job.cleanup()
class AnimationWindow(PyDialog):
"""
+-------------------+
| Animation |
+-------------------------+
| icase ______ |
| scale ______ Default |
| time ______ Default |
| |
| nframes ______ Default |
| resolu. ______ Default |
| Dir ______ Browse |
| iFrame ______ |
| |
| Animations: |
| o Scale, Phase, Time | # TODO: add time
| |
| x delete images |
| x repeat | # TODO: change to an integer
| x make gif |
| |
| Step, RunAll |
| Close |
+-------------------------+
TODO: add key-frame support
"""
def __init__(self, data, win_parent=None):
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
self.istep = 0
self._animate_type = 'time'
self._updated_animation = False
self._icase = data['icase']
self._default_name = data['name']
self._default_time = data['time']
self._default_fps = data['frames/sec']
self._default_resolution = data['resolution']
self._scale = data['scale']
self._default_scale = data['default_scale']
self._default_is_scale = data['is_scale']
self._phase = data['phase']
self._default_phase = data['default_phase']
self._default_dirname = data['dirname']
self._default_gif_name = os.path.join(self._default_dirname,
data['name'] + '.gif')
self.animation_types = [
'Animate Scale',
]
#'Animate Phase',
#'Animate Time',
#'Animate Frequency Sweep'
#]
self.setWindowTitle('Animate Model')
self.create_widgets()
self.create_layout()
self.set_connections()
self.is_gui = False
if hasattr(self.win_parent, '_updated_legend'):
self.win_parent.is_animate_open = True
self.is_gui = True
def create_widgets(self):
"""creates the menu objects"""
icase_max = 1000 # TODO: update 1000
self.icase = QLabel("iCase:")
self.icase_edit = QSpinBox(self)
self.icase_edit.setRange(1, icase_max)
self.icase_edit.setSingleStep(1)
self.icase_edit.setValue(self._icase)
self.icase_edit.setToolTip(
'Case Number for the Scale/Phase Animation Type.\n'
'Defaults to the result you had shown when you clicked "Create Animation".\n'
'iCase can be seen by clicking "Apply" on a result.')
self.scale = QLabel("Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
self.scale_edit.setToolTip('Scale factor of the "deflection"')
self.scale_button.setToolTip('Sets the scale factor of the gif to %s' %
self._scale)
self.time = QLabel("Total Time (sec):")
self.time_edit = QDoubleSpinBox(self)
self.time_edit.setValue(self._default_time)
self.time_edit.setRange(0.1, 10.0)
self.time_edit.setDecimals(2)
self.time_edit.setSingleStep(0.1)
self.time_button = QPushButton("Default")
self.time_edit.setToolTip("Total time of the gif")
self.time_button.setToolTip('Sets the total time of the gif to %.2f' %
self._default_time)
self.fps = QLabel("Frames/Second:")
self.fps_edit = QSpinBox(self)
self.fps_edit.setRange(1, 60)
self.fps_edit.setSingleStep(1)
self.fps_edit.setValue(self._default_fps)
self.fps_button = QPushButton("Default")
self.fps_edit.setToolTip(
"A higher FPS is smoother, but may not play well for large gifs")
self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps)
self.resolution = QLabel("Resolution Scale:")
self.resolution_edit = QSpinBox(self)
self.resolution_edit.setRange(1, 5)
self.resolution_edit.setSingleStep(1)
self.resolution_edit.setValue(self._default_resolution)
self.resolution_button = QPushButton("Default")
self.resolution_edit.setToolTip(
'Scales the window resolution by an integer factor')
self.resolution_button.setToolTip('Sets the resolution to %s' %
self._default_resolution)
#-----------------
# Time plot
self.icase_start = QLabel("iCase Start:")
self.icase_start_edit = QSpinBox(self)
self.icase_start_edit.setRange(0, icase_max)
self.icase_start_edit.setSingleStep(1)
self.icase_start_edit.setValue(self._icase)
self.icase_start_button = QPushButton("Default")
self.icase_end = QLabel("iCase End:")
self.icase_end_edit = QSpinBox(self)
self.icase_end_edit.setRange(0, icase_max)
self.icase_end_edit.setSingleStep(1)
self.icase_end_edit.setValue(self._icase)
self.icase_end_button = QPushButton("Default")
self.icase_delta = QLabel("iCase Delta:")
self.icase_delta_edit = QSpinBox(self)
self.icase_delta_edit.setRange(1, icase_max)
self.icase_delta_edit.setSingleStep(1)
self.icase_delta_edit.setValue(1)
self.icase_delta_button = QPushButton("Default")
self.min_value = QLabel("Min Value:")
self.min_value_edit = QLineEdit(str(0.))
#self.min_value_edit.setRange(1, 1000)
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.min_value_button = QPushButton("Default")
self.max_value = QLabel("Max Value:")
self.max_value_edit = QLineEdit(str(1.))
#self.min_value_edit.setRange(1, 1000) # TODO: update 1000
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.max_value_button = QPushButton("Default")
self.icase_start_edit.setToolTip('The first frame of the animation')
self.icase_end_edit.setToolTip(
'The last frame of the animation\n'
'Assumes icase_start + nframes * icase_delta = icase_end')
self.icase_delta_edit.setToolTip(
'The frame step size (to skip non-consecutive results).\n'
'Frame skipping can be used to:\n'
" - skip across results that you don't want to plot\n"
' - adjust the FPS')
self.min_value_edit.setToolTip(
'Min value of the legend (not supported)')
self.max_value_edit.setToolTip(
'Max value of the legend (not supported)')
#'time' : 0.,
#'default_time' : 0,
#'icase_start' : 10,
#'icase_delta' : 3,
#'min_value' : 0.,
#'max_value' : 1000.,
self.browse_folder = QLabel('Output Directory:')
self.browse_folder_edit = QLineEdit(str(self._default_dirname))
self.browse_folder_button = QPushButton('Browse')
self.browse_folder_edit.setToolTip(
'Location to save the png/gif files')
self.gif = QLabel("Gif Filename:")
self.gif_edit = QLineEdit(str(self._default_name + '.gif'))
self.gif_button = QPushButton('Default')
self.gif_edit.setToolTip('Name of the gif')
self.gif_button.setToolTip('Sets the name of the gif to %s.gif' %
self._default_name)
# scale / phase
self.animate_scale_radio = QRadioButton("Animate Scale")
self.animate_phase_radio = QRadioButton("Animate Phase")
self.animate_time_radio = QRadioButton("Animate Time")
self.animate_freq_sweeep_radio = QRadioButton(
"Animate Frequency Sweep")
self.animate_scale_radio.setToolTip(
'Animates the scale factor based on the "Animation Type"')
self.animate_time_radio.setToolTip('Animates the time/load/mode step')
self.animate_scale_radio.setChecked(self._default_is_scale)
self.animate_phase_radio.setChecked(not self._default_is_scale)
self.animate_time_radio.setChecked(False)
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
self.animate_phase_radio.setDisabled(True)
self.animate_phase_radio.setToolTip('Animates the phase angle '
'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n')
self.animate_freq_sweeep_radio.setDisabled(True)
self.animate_freq_sweeep_radio.setToolTip(
'Animates a complex result across a range of frequencies (not supported)'
)
self.animation_type = QLabel("Animation Type:")
animation_type = OrderedDict()
#scale_msg = 'Scale\n'
#phase_msg = 'Phase\n'
#time_msg = 'Time\n'
#animation_types = [
#('Animate Scale', scale_msg),
#('Animate Phase', phase_msg),
#('Animate Time', time_msg),
##'Animate Frequency Sweep'
#]
if self._phase is not None:
self.animation_types.append('Animate Phase')
self.animation_types.append('Animate Time')
self.animation_profile = QLabel("Animation Profile:")
self.animation_profile_edit = QComboBox()
for animation_profile in ANIMATION_PROFILES:
self.animation_profile_edit.addItem(animation_profile)
self.animation_profile_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit = QComboBox()
# TODO: add a tooltip for each item
for animation_type in self.animation_types:
self.animation_type_edit.addItem(animation_type)
#self.animation_type_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit.setToolTip(msg)
self.csv_profile = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_browse_button = QPushButton('Browse')
self.csv_profile_edit.setToolTip(
'The path to the CSV file of (Scale1, Scale2, Scale3, ...)')
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.animate_scale_radio)
horizontal_vertical_group.addButton(self.animate_phase_radio)
horizontal_vertical_group.addButton(self.animate_time_radio)
horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio)
# one / two sided
self.onesided_radio = QRadioButton("One Sided")
self.onesided_radio.setToolTip(
"A one sided gif doesn't return to the starting point (e.g., 0 to 360 degrees)"
)
self.twosided_radio = QRadioButton("Two Sided")
self.twosided_radio.setToolTip(
'A two sided gif returns to the starting point (e.g., 0 to 10 to 0)'
)
if self._default_phase is None:
self.onesided_radio.setChecked(False)
self.twosided_radio.setChecked(True)
else:
self.onesided_radio.setChecked(True)
self.twosided_radio.setChecked(False)
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.onesided_radio)
horizontal_vertical_group.addButton(self.twosided_radio)
# animate in gui
self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?")
self.animate_in_gui_checkbox.setChecked(True)
# make images
self.make_images_checkbox = QCheckBox("Make images?")
self.make_images_checkbox.setChecked(True)
# make images
self.overwrite_images_checkbox = QCheckBox("Overwrite images?")
self.overwrite_images_checkbox.setChecked(True)
# delete images when finished
self.delete_images_checkbox = QCheckBox("Delete images when finished?")
self.delete_images_checkbox.setChecked(True)
# endless loop
self.repeat_checkbox = QCheckBox("Repeat?")
self.repeat_checkbox.setChecked(True)
self.repeat_checkbox.setToolTip(
"Repeating creates an infinitely looping gif")
# endless loop
self.make_gif_checkbox = QCheckBox("Make Gif?")
if IS_IMAGEIO:
self.make_gif_checkbox.setChecked(True)
else:
self.make_gif_checkbox.setChecked(False)
self.make_gif_checkbox.setEnabled(False)
self.make_gif_checkbox.setToolTip(
'imageio is not available; install it')
# bottom buttons
self.step_button = QPushButton("Step")
self.stop_button = QPushButton("Stop")
self.run_button = QPushButton("Run All")
#self.apply_button = QPushButton("Apply")
#self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Close")
#self.set_grid_time(enabled=False)
#self.set_grid_scale(enabled=self._default_is_scale)
if self._default_phase:
self.on_animate_phase(force=True)
else:
self.on_animate_scale(force=True)
def set_connections(self):
"""creates button actions"""
self.scale_button.clicked.connect(self.on_default_scale)
self.time_button.clicked.connect(self.on_default_time)
self.fps_button.clicked.connect(self.on_default_fps)
self.resolution_button.clicked.connect(self.on_default_resolution)
self.browse_folder_button.clicked.connect(self.on_browse_folder)
self.csv_profile_browse_button.clicked.connect(self.on_browse_csv)
self.gif_button.clicked.connect(self.on_default_name)
self.step_button.clicked.connect(self.on_step)
self.stop_button.clicked.connect(self.on_stop)
self.run_button.clicked.connect(self.on_run)
#self.animate_scale_radio.clicked.connect(self.on_animate_scale)
#self.animate_phase_radio.clicked.connect(self.on_animate_phase)
#self.animate_time_radio.clicked.connect(self.on_animate_time)
self.animation_type_edit.currentIndexChanged.connect(self.on_animate)
#self.animate_freq_sweeep_radio
#self.apply_button.clicked.connect(self.on_apply)
#self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
self.animate_in_gui_checkbox.clicked.connect(self.on_animate_in_gui)
self.animate_in_gui_checkbox.setChecked(True)
self.on_animate_in_gui()
def on_animate_in_gui(self):
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
enable = not animate_in_gui
self.make_images_checkbox.setEnabled(enable)
self.delete_images_checkbox.setEnabled(enable)
self.make_gif_checkbox.setEnabled(enable)
self.repeat_checkbox.setEnabled(enable)
self.resolution_button.setEnabled(enable)
self.resolution_edit.setEnabled(enable)
self.gif_edit.setEnabled(enable)
self.gif_button.setEnabled(enable)
self.browse_folder_button.setEnabled(enable)
self.browse_folder_edit.setEnabled(enable)
self.step_button.setEnabled(enable)
def on_animate(self, value):
"""
animate pulldown
Parameters
----------
value : int
index in animation_types
"""
#animation_types = ['Animate Scale', 'Animate Phase', 'Animate Time',
#'Animate Frequency Sweep']
animation_type = self.animation_types[value]
if animation_type == 'Animate Scale':
self.on_animate_scale()
elif animation_type == 'Animate Phase':
self.on_animate_phase()
elif animation_type == 'Animate Time':
self.on_animate_time()
else:
raise NotImplementedError('value = ', value)
def on_animate_time(self, force=False):
"""enables the secondary input"""
#print('on_animate_time')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'time')
self.set_grid_time(True, 'time')
self._animate_type = 'time'
def on_animate_scale(self, force=False):
"""enables the secondary input"""
#print('on_animate_scale')
self.set_grid_scale(True, 'scale')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'scale')
self._animate_type = 'scale'
def on_animate_phase(self, force=False):
"""enables the secondary input"""
#print('on_animate_phase')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'phase')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'phase')
self._animate_type = 'phase'
def set_grid_scale(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_scale; enabled = %r' % (word, enabled))
self.animation_profile.setEnabled(enabled)
self.animation_profile_edit.setEnabled(enabled)
# TODO: doesn't work...
#self.csv_profile.setEnabled(enabled)
#self.csv_profile_edit.setEnabled(enabled)
#self.csv_profile_button.setEnabled(enabled)
def set_grid_time(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_time; enabled = %r' % (word, enabled))
self.icase_start.setEnabled(enabled)
self.icase_start_edit.setEnabled(enabled)
self.icase_start_button.setEnabled(enabled)
self.icase_end.setEnabled(enabled)
self.icase_end_edit.setEnabled(enabled)
self.icase_end_button.setEnabled(enabled)
self.icase_delta.setEnabled(enabled)
self.icase_delta_edit.setEnabled(enabled)
self.icase_delta_button.setEnabled(enabled)
self.min_value.setEnabled(enabled)
self.min_value_edit.setEnabled(enabled)
self.min_value_button.setEnabled(enabled)
self.max_value.setEnabled(enabled)
self.max_value_edit.setEnabled(enabled)
self.max_value_button.setEnabled(enabled)
self.icase.setEnabled(not enabled)
self.icase_edit.setEnabled(not enabled)
self.fps.setEnabled(not enabled)
self.fps_edit.setEnabled(not enabled)
self.fps_button.setEnabled(not enabled)
def on_browse_folder(self):
"""opens a folder dialog"""
dirname = open_directory_dialog(self, 'Select a Directory')
if not dirname:
return
self.browse_folder_edit.setText(dirname)
def on_browse_csv(self):
"""opens a file dialog"""
default_filename = ''
file_types = 'Delimited Text (*.txt; *.dat; *.csv)'
dirname = open_file_dialog(self, 'Select a CSV File', default_filename,
file_types)
if not dirname:
return
self.csv_profile_browse_button.setText(dirname)
def on_default_name(self):
"""sets the default gif name"""
self.gif_edit.setText(self._default_name + '.gif')
def on_default_scale(self):
"""sets the default displacement scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_time(self):
"""sets the default gif time"""
self.time_edit.setValue(self._default_time)
def on_default_fps(self):
"""sets the default FPS"""
self.fps_edit.setValue(self._default_fps)
def on_default_resolution(self):
"""sets the default image resolution scale factor"""
self.resolution_edit.setValue(self._default_resolution)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.icase, 0, 0)
grid.addWidget(self.icase_edit, 0, 1)
grid.addWidget(self.scale, 1, 0)
grid.addWidget(self.scale_edit, 1, 1)
grid.addWidget(self.scale_button, 1, 2)
grid.addWidget(self.time, 2, 0)
grid.addWidget(self.time_edit, 2, 1)
grid.addWidget(self.time_button, 2, 2)
# spacer
spacer = QLabel('')
grid.addWidget(self.fps, 3, 0)
grid.addWidget(self.fps_edit, 3, 1)
grid.addWidget(self.fps_button, 3, 2)
grid.addWidget(self.resolution, 4, 0)
grid.addWidget(self.resolution_edit, 4, 1)
grid.addWidget(self.resolution_button, 4, 2)
grid.addWidget(self.browse_folder, 5, 0)
grid.addWidget(self.browse_folder_edit, 5, 1)
grid.addWidget(self.browse_folder_button, 5, 2)
grid.addWidget(self.gif, 6, 0)
grid.addWidget(self.gif_edit, 6, 1)
grid.addWidget(self.gif_button, 6, 2)
grid.addWidget(self.animation_type, 7, 0)
grid.addWidget(self.animation_type_edit, 7, 1)
grid.addWidget(spacer, 8, 0)
#----------
#Time
grid_time = QGridLayout()
grid_time.addWidget(self.icase_start, 0, 0)
grid_time.addWidget(self.icase_start_edit, 0, 1)
#grid_time.addWidget(self.icase_start_button, 0, 2)
grid_time.addWidget(self.icase_end, 1, 0)
grid_time.addWidget(self.icase_end_edit, 1, 1)
#grid_time.addWidget(self.icase_end_button, 1, 2)
grid_time.addWidget(self.icase_delta, 2, 0)
grid_time.addWidget(self.icase_delta_edit, 2, 1)
#grid_time.addWidget(self.icase_delta_button, 2, 2)
#grid_time.addWidget(self.min_value, 3, 0)
#grid_time.addWidget(self.min_value_edit, 3, 1)
#grid_time.addWidget(self.min_value_button, 3, 2)
#grid_time.addWidget(self.max_value, 4, 0)
#grid_time.addWidget(self.max_value_edit, 4, 1)
#grid_time.addWidget(self.max_value_button, 4, 2)
grid_time.addWidget(spacer, 5, 0)
#--------------
grid_scale = QGridLayout()
grid_scale.addWidget(self.animation_profile, 0, 0)
grid_scale.addWidget(self.animation_profile_edit, 0, 1)
#grid_scale.addWidget(self.csv_profile, 1, 0)
#grid_scale.addWidget(self.csv_profile_edit, 1, 1)
#grid_scale.addWidget(self.csv_profile_browse_button, 1, 2)
self.csv_profile = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_button = QPushButton('Browse')
#box_time = QVBoxLayout()
# TODO: It's super annoying that the animate time box doesn't
# line up with the previous box
box_scale = QGroupBox('Animate Scale')
box_scale.setLayout(grid_scale)
box_time = QGroupBox('Animate Time')
box_time.setLayout(grid_time)
#----------
grid2 = QGridLayout()
#grid2.addWidget(self.animate_scale_radio, 8, 0)
#grid2.addWidget(self.animate_phase_radio, 8, 1)
#grid2.addWidget(self.animate_time_radio, 8, 2)
#grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3)
grid2.addWidget(self.animate_in_gui_checkbox, 10, 0)
grid2.addWidget(self.make_images_checkbox, 11, 0)
#grid2.addWidget(self.overwrite_images_checkbox, 11, 0)
grid2.addWidget(self.delete_images_checkbox, 11, 1)
grid2.addWidget(self.make_gif_checkbox, 11, 2)
grid2.addWidget(self.repeat_checkbox, 12, 0)
grid2.addWidget(spacer, 13, 0)
grid_hbox = QHBoxLayout()
grid_hbox.addWidget(spacer)
grid_hbox.addLayout(grid2)
grid_hbox.addWidget(spacer)
# bottom buttons
step_run_box = QHBoxLayout()
step_run_box.addWidget(self.step_button)
step_run_box.addWidget(self.stop_button)
step_run_box.addWidget(self.run_button)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addWidget(box_scale)
vbox.addWidget(box_time)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid_hbox)
vbox.addStretch()
vbox.addLayout(step_run_box)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def on_step(self):
"""click the Step button"""
passed, validate_out = self.on_validate()
if passed:
try:
self._make_gif(validate_out, istep=self.istep)
self.istep += 1
except IndexError:
self._make_gif(validate_out, istep=0)
self.istep += 1
def on_stop(self):
passed, validate_out = self.on_validate()
if passed:
self._make_gif(validate_out, stop_animation=True)
def on_run(self):
"""click the Run button"""
self.istep = 0
passed, validate_out = self.on_validate()
if passed:
self._make_gif(validate_out, istep=None)
return passed
def _make_gif(self, validate_out, istep=None, stop_animation=False):
"""interface for making the gif"""
icase, scale, time, fps, animate_in_gui, magnify, output_dir, gifbase = validate_out
gif_filename = None
if not stop_animation and not animate_in_gui:
if gifbase.lower().endswith('.gif'):
gifbase = gifbase[:-4]
gif_filename = os.path.join(output_dir, gifbase + '.gif')
animate_scale = self.animate_scale_radio.isChecked()
animate_phase = self.animate_phase_radio.isChecked()
animate_time = self.animate_time_radio.isChecked()
animate_scale = False
animate_phase = False
animate_time = False
if self._animate_type == 'scale':
animate_scale = True
elif self._animate_type == 'phase':
animate_phase = True
elif self._animate_type == 'time':
animate_time = True
else:
raise NotImplementedError(self._animate_type)
make_images = self.make_images_checkbox.isChecked()
delete_images = self.delete_images_checkbox.isChecked()
make_gif = self.make_gif_checkbox.isChecked()
key = str(self.animation_profile_edit.currentText())
#profile = ANIMATION_PROFILES[key]
#ANIMATION_PROFILES['0 to Scale'] = [0., 1.]
#ANIMATION_PROFILES['0 to Scale to 0'] = [0., 1., 0.]
if key == '0 to Scale':
onesided = True
else:
onesided = False
icase_start = self.icase_start_edit.value()
icase_end = self.icase_end_edit.value()
icase_delta = self.icase_delta_edit.value()
#onesided = self.onesided_radio.isChecked()
bool_repeat = self.repeat_checkbox.isChecked(
) # TODO: change this to an integer
if bool_repeat:
nrepeat = 0
else:
nrepeat = 1
#self.out_data['is_shown'] = self.show_radio.isChecked()
#icase = self._icase
if self.is_gui:
self.win_parent.win_parent.make_gif(
gif_filename,
scale,
istep=istep,
animate_scale=animate_scale,
animate_phase=animate_phase,
animate_time=animate_time,
icase=icase,
icase_start=icase_start,
icase_end=icase_end,
icase_delta=icase_delta,
time=time,
onesided=onesided,
nrepeat=nrepeat,
fps=fps,
magnify=magnify,
make_images=make_images,
delete_images=delete_images,
make_gif=make_gif,
stop_animation=stop_animation,
animate_in_gui=animate_in_gui,
)
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
def on_validate(self):
"""checks to see if the input is valid"""
icase, flag0 = self.check_int(self.icase_edit)
scale, flag1 = self.check_float(self.scale_edit)
time, flag2 = self.check_float(self.time_edit)
fps, flag3 = self.check_float(self.fps_edit)
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
if animate_in_gui:
passed = all([flag0, flag1, flag2, flag3])
return passed, (icase, scale, time, fps, animate_in_gui, None,
None, None)
magnify, flag4 = self.check_int(self.resolution_edit)
output_dir, flag5 = self.check_path(self.browse_folder_edit)
gifbase, flag6 = self.check_name(self.gif_edit)
passed = all([flag0, flag1, flag2, flag3, flag4, flag5, flag6])
return passed, (icase, scale, time, fps, animate_in_gui, magnify,
output_dir, gifbase)
@staticmethod
def check_name(cell):
"""verifies that the data is string-able"""
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def check_path(self, cell):
"""verifies that the path exists"""
text, passed = self.check_name(cell)
if not passed:
return None, False
if os.path.exists(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
#def on_ok(self):
#"""click the OK button"""
#passed = self.on_apply()
#if passed:
#self.win_parent._animation_window_shown = False
#self.close()
##self.destroy()
def on_cancel(self):
"""click the Cancel button"""
self.on_stop()
self.out_data['close'] = True
self.close()
class VolumeEditorWidget(QWidget):
def __init__( self, volumeeditor, parent=None ):
super(VolumeEditorWidget, self).__init__(parent=parent)
self._ve = volumeeditor
self.setFocusPolicy(Qt.StrongFocus)
# setup quadview
self.quadview = QuadView(self)
self.quadview.addWidget(0, self._ve.imageViews[2])
self.quadview.addWidget(1, self._ve.imageViews[0])
self.quadview.addWidget(2, self._ve.imageViews[1])
#3d overview
#self.overview = OverviewScene(self, self._ve._shape[1:4])
#self.quadview.addWidget(3, self.overview)
self.quadview.addWidget(3, QWidget(self))
#FIXME: resurrect
#self.overview.changedSlice.connect(self.changeSlice)
#self._ve.changedSlice.connect(self.overview.ChangeSlice)
# layout
viewingLayout = QVBoxLayout()
viewingLayout.setContentsMargins(10,2,0,2)
viewingLayout.setSpacing(0)
viewingLayout.addWidget(self.quadview)
self.quadview.setContentsMargins(0,0,10,0)
# Label below views
labelLayout = QHBoxLayout()
labelLayout.setMargin(0)
labelLayout.setSpacing(5)
labelLayout.setContentsMargins(0,0,0,0)
self.posLabel = QLabel()
self.pixelValuesLabel = QLabel()
labelLayout.addWidget(self.posLabel)
labelLayout.addWidget(self.pixelValuesLabel)
labelLayout.addStretch()
viewingLayout.addLayout(labelLayout)
# Right side toolbox
self._toolBox = QWidget()
self._toolBox.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self._toolBoxLayout = QVBoxLayout()
self._toolBoxLayout.setMargin(5)
self._toolBox.setLayout(self._toolBoxLayout)
self._toolBoxLayout.addStretch()
# Toggle slice intersection marks
self.indicateSliceIntersectionButton = QToolButton()
self.indicateSliceIntersectionButton.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.indicateSliceIntersectionButton.setText("Indicate Current Position")
self.indicateSliceIntersectionButton.setCheckable(True)
self.indicateSliceIntersectionButton.setChecked(True)
self._toolBoxLayout.addWidget(self.indicateSliceIntersectionButton)
# Channel Selector QComboBox in right side tool box
self._channelSpin = QSpinBox()
self._channelSpin.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self._channelSpin.setEnabled(True)
channelLayout = QHBoxLayout()
channelLayout.addWidget(self._channelSpin)
self._channelSpinLabel = QLabel("Channel:")
self._toolBoxLayout.addWidget(self._channelSpinLabel)
self._toolBoxLayout.addLayout(channelLayout)
#time selector
self._timeSpin = QSpinBox()
self._timeSpin.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self._timeSpin.setEnabled(True)
timeLayout = QHBoxLayout()
timeLayout.addWidget(self._timeSpin)
self._timeSpinLabel = QLabel("Time:")
self._toolBoxLayout.addWidget(self._timeSpinLabel)
self._toolBoxLayout.addLayout(timeLayout)
self._toolBoxLayout.setAlignment(Qt.AlignTop)
self._channelSpin.setRange(0,self._ve._shape[-1] - 1)
self._timeSpin.setRange(0,self._ve._shape[0] - 1)
def setChannel(c):
print "set channel = %d, posModel has channel = %d" % (c, self._ve.posModel.channel)
if c == self._ve.posModel.channel:
return
self._ve.posModel.channel = c
self._channelSpin.valueChanged.connect(setChannel)
def getChannel(newC):
self._channelSpin.setValue(newC)
self._ve.posModel.channelChanged.connect(getChannel)
def setTime(t):
print "set channel = %d, posModel has time = %d" % (t, self._ve.posModel.time)
if t == self._ve.posModel.time:
return
self._ve.posModel.time = t
self._timeSpin.valueChanged.connect(setTime)
def getTime(newT):
self._timeSpin.setValue(newT)
self._ve.posModel.timeChanged.connect(getTime)
# setup the layout for display
self.splitter = QSplitter()
self.splitter.setContentsMargins(0,0,0,0)
tempWidget = QWidget()
tempWidget.setLayout(viewingLayout)
self.splitter.addWidget(tempWidget)
self.splitter.addWidget(self._toolBox)
splitterLayout = QVBoxLayout()
splitterLayout.setMargin(0)
splitterLayout.setSpacing(0)
splitterLayout.addWidget(self.splitter)
self.setLayout(splitterLayout)
# drawing
axisLabels = ["X:", "Y:", "Z:"]
for i, v in enumerate(self._ve.imageViews):
v.hud = SliceSelectorHud()
#connect interpreter
v.hud.sliceSelector.valueChanged.connect(partial(self._ve.navInterpret.changeSliceAbsolute, axis=i))
#hud
v.hud.bgColor = self._ve.navCtrl.axisColors[i] #FIXME
v.hud.label = axisLabels[i]
v.hud.minimum = 0
v.hud.maximum = self._ve.posModel.volumeExtent(i)
def toggleSliceIntersection(state):
self._ve.navCtrl.indicateSliceIntersection = state
self.indicateSliceIntersectionButton.toggled.connect(toggleSliceIntersection)
#Enabling this makes cursor movement too slow...
#self._ve.posModel.cursorPositionChanged.connect(self._updateInfoLabels)
# shortcuts
self._initShortcuts()
self.updateGeometry()
self.update()
self.quadview.update()
def _shortcutHelper(self, keySequence, group, description, parent, function, context = None, enabled = None):
shortcut = QShortcut(QKeySequence(keySequence), parent, member=function, ambiguousMember=function)
if context != None:
shortcut.setContext(context)
if enabled != None:
shortcut.setEnabled(True)
return shortcut, group, description
def _initShortcuts(self):
self.shortcuts = []
self.shortcuts.append(self._shortcutHelper("Ctrl+Z", "Labeling", "History undo", self, self._ve.historyUndo, Qt.ApplicationShortcut, True))
self.shortcuts.append(self._shortcutHelper("Ctrl+Shift+Z", "Labeling", "History redo", self, self._ve.historyRedo, Qt.ApplicationShortcut, True))
self.shortcuts.append(self._shortcutHelper("Ctrl+Y", "Labeling", "History redo", self, self._ve.historyRedo, Qt.ApplicationShortcut, True))
self.shortcuts.append(self._shortcutHelper("l", "Labeling", "Go to next label (cyclic, forward)", self, self._ve.nextLabel))
self.shortcuts.append(self._shortcutHelper("k", "Labeling", "Go to previous label (cyclic, backwards)", self, self._ve.prevLabel))
def fullscreenView(axis):
m = not self.quadview.maximized
print "maximize axis=%d = %r" % (axis, m)
self.quadview.setMaximized(m, axis)
maximizeShortcuts = ['x', 'y', 'z']
maximizeViews = [1, 2, 0]
for i, v in enumerate(self._ve.imageViews):
self.shortcuts.append(self._shortcutHelper(maximizeShortcuts[i], "Navigation", \
"Enlarge slice view %s to full size" % maximizeShortcuts[i], \
self, partial(fullscreenView, maximizeViews[i]), Qt.WidgetShortcut))
#self.shortcuts.append(self._shortcutHelper("n", "Labeling", "Increase brush size", v,self._ve._drawManager.brushSmaller, Qt.WidgetShortcut))
#self.shortcuts.append(self._shortcutHelper("m", "Labeling", "Decrease brush size", v, self._ve._drawManager.brushBigger, Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("+", "Navigation", "Zoom in", v, v.zoomIn, Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("-", "Navigation", "Zoom out", v, v.zoomOut, Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("q", "Navigation", "Switch to next channel", v, self._ve.nextChannel, Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("a", "Navigation", "Switch to previous channel", v, self._ve.previousChannel, Qt.WidgetShortcut))
def sliceDelta(axis, delta):
newPos = copy.copy(self._ve.posModel.slicingPos)
newPos[axis] += delta
self._ve.posModel.slicingPos = newPos
self.shortcuts.append(self._shortcutHelper("p", "Navigation", "Slice up", v, partial(sliceDelta, i, 1), Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("o", "Navigation", "Slice down", v, partial(sliceDelta, i, -1), Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("Ctrl+Up", "Navigation", "Slice up", v, partial(sliceDelta, i, 1), Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("Ctrl+Down", "Navigation", "Slice down", v, partial(sliceDelta, i, -1), Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("Ctrl+Shift+Up", "Navigation", "10 slices up", v, partial(sliceDelta, i, 10), Qt.WidgetShortcut))
self.shortcuts.append(self._shortcutHelper("Ctrl+Shift+Down", "Navigation", "10 slices down", v, partial(sliceDelta, i, -10), Qt.WidgetShortcut))
def _updateInfoLabels(self, pos):
if any((pos[i] < 0 or pos[i] >= self._ve.posModel.shape[i] for i in xrange(3))):
self._ve.posLabel.setText("")
return
self.posLabel.setText("<b>x:</b> %03i <b>y:</b> %03i <b>z:</b> %03i" % (pos[0], pos[1], pos[2]))
class CompletionSection(QWidget):
def __init__(self):
super(CompletionSection, self).__init__()
EditorConfiguration.install_widget(self.tr("Autocompletado"), self)
container = QVBoxLayout(self)
group_complete = QGroupBox(self.tr("Completar:"))
box = QGridLayout(group_complete)
box.setContentsMargins(20, 5, 20, 5)
self.check_bracket = QCheckBox(self.tr("Corchetes []"))
box.addWidget(self.check_bracket, 0, 0)
self.check_paren = QCheckBox(self.tr("Paréntesis ()"))
box.addWidget(self.check_paren, 0, 1)
self.check_key = QCheckBox(self.tr("Llaves {}"))
box.addWidget(self.check_key, 1, 0)
self.check_quote = QCheckBox(self.tr("Comillas Dobles \" \""))
box.addWidget(self.check_quote, 1, 1)
self.check_single_quote = QCheckBox(self.tr("Comillas Simples ' '"))
box.addWidget(self.check_single_quote, 2, 0)
group_completion = QGroupBox(self.tr("Completado de Código:"))
box = QGridLayout(group_completion)
box.setContentsMargins(20, 5, 20, 5)
self.check_completion = QCheckBox(self.tr("Activar Completado"))
box.addWidget(self.check_completion, 0, 0)
self.check_document = QCheckBox(self.tr("Basado en el código"))
box.addWidget(self.check_document, 0, 1)
self.check_keywords = QCheckBox(self.tr("Palabras Claves"))
box.addWidget(self.check_keywords, 1, 0)
self.check_cs = QCheckBox(
self.tr("Sensitivo a mayúsculas y minúsculas"))
box.addWidget(self.check_cs, 1, 1)
self.check_replace_word = QCheckBox(self.tr("Reemplazar Palabra"))
box.addWidget(self.check_replace_word, 2, 0)
self.check_show_single = QCheckBox(self.tr("Mostrar Simple"))
box.addWidget(self.check_show_single, 2, 1)
hbox = QHBoxLayout()
hbox.addWidget(
QLabel(self.tr("Número de caractéres para mostrar lista:")))
self.spin_threshold = QSpinBox()
self.spin_threshold.setMinimum(1)
self.spin_threshold.setFixedWidth(100)
hbox.addWidget(self.spin_threshold)
box.addLayout(hbox, 3, 0, Qt.AlignLeft)
# Agrupo al contenedor principal
container.addWidget(group_complete)
container.addWidget(group_completion)
container.addItem(
QSpacerItem(0, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
self._state_change(self.check_completion.isChecked())
# Conexiones
self.check_completion.stateChanged[int].connect(self._state_change)
# Configuration
self.check_key.setChecked(
settings.get_setting('editor/complete-brace'))
self.check_bracket.setChecked("[" in settings.BRACES)
self.check_paren.setChecked("(" in settings.BRACES)
self.check_quote.setChecked('""' in settings.QUOTES)
#settings.get_setting('editor/complete-double-quote'))
self.check_single_quote.setChecked("''" in settings.QUOTES)
#settings.get_setting('editor/complete-single-quote'))
self.check_completion.setChecked(
settings.get_setting('editor/completion'))
self.spin_threshold.setValue(
settings.get_setting('editor/completion-threshold'))
self.check_keywords.setChecked(
settings.get_setting('editor/completion-keywords'))
self.check_document.setChecked(
settings.get_setting('editor/completion-document'))
self.check_cs.setChecked(settings.get_setting('editor/completion-cs'))
self.check_replace_word.setChecked(
settings.get_setting('editor/completion-replace-word'))
self.check_show_single.setChecked(
settings.get_setting('editor/completion-single'))
def _state_change(self, value):
state = bool(value)
self.check_document.setEnabled(state)
self.check_keywords.setEnabled(state)
self.check_cs.setEnabled(state)
self.check_replace_word.setEnabled(state)
self.check_show_single.setEnabled(state)
self.spin_threshold.setEnabled(state)
def save(self):
settings.set_setting('editor/complete-brace',
self.check_key.isChecked())
settings.set_setting('editor/complete-bracket',
self.check_bracket.isChecked())
if self.check_bracket.isChecked():
settings.BRACES['['] = ']'
elif ('[') in settings.BRACES:
del settings.BRACES['[']
settings.set_setting('editor/complete-paren',
self.check_paren.isChecked())
if self.check_paren.isChecked():
settings.BRACES['('] = ')'
elif ('(') in settings.BRACES:
del settings.BRACES['(']
settings.set_setting('editor/complete-double-quote',
self.check_quote.isChecked())
if self.check_quote.isChecked():
settings.QUOTES.append('""')
elif '""' in settings.QUOTES:
settings.QUOTES.remove('""')
settings.set_setting('editor/complete-single-quote',
self.check_single_quote.isChecked())
if self.check_single_quote.isChecked():
settings.QUOTES.append('""')
elif "''" in settings.QUOTES:
settings.QUOTES.remove("''")
code_completion = self.check_completion.isChecked()
settings.set_setting('editor/completion', code_completion)
settings.set_setting('editor/completion-threshold',
self.spin_threshold.value())
settings.set_setting('editor/completion-keywords',
self.check_keywords.isChecked())
settings.set_setting('editor/completion-document',
self.check_document.isChecked())
settings.set_setting('editor/completion-cs', self.check_cs.isChecked())
settings.set_setting('editor/completion-replace-word',
self.check_replace_word.isChecked())
settings.set_setting('editor/completion-single',
self.check_show_single.isChecked())
editor_container = Edis.get_component("principal")
editor = editor_container.get_active_editor()
if editor is not None:
editor.active_code_completion(code_completion)