def _setup_ui(self):
self.setSpacing(12)
self.setAlignment(Qt.AlignCenter)
if 'BalanceRatio' in self._name:
icon_path = 'wb'
else:
icon_path = self._name.lower()
# icon
label = QLabel()
label.setToolTip(self._name)
label.setPixmap(icons.get(icon_path))
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
label.setFixedWidth(45)
self.addWidget(label)
# slider
self._slider = QSlider(Qt.Horizontal)
self._slider.setMinimum(0)
self._slider.setMaximum(self._length)
if icon_path == 'wb':
self._slider.setObjectName(self._name)
self._slider.valueChanged.connect(self._on_slider_changed)
self.addWidget(self._slider)
# value
self._label = QLabel()
self._label.setContentsMargins(0, 0, 0, 4)
self._label.setFixedWidth(45)
self.addWidget(self._label)
self._update()
def __init__(self, parent, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
self.setModal(False)
self.setWindowTitle("Select sources by...")
lo = QVBoxLayout(self)
lo.setContentsMargins(10, 10, 10, 10)
lo.setSpacing(5)
# select by
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
# lab = QLabel("Select:")
# lo1.addWidget(lab)
self.wselby = QComboBox(self)
lo1.addWidget(self.wselby, 0)
self.wselby.activated[str].connect(self._setup_selection_by)
# under/over
self.wgele = QComboBox(self)
lo1.addWidget(self.wgele, 0)
self.wgele.addItems([">", ">=", "<=", "<", "sum<=", "sum>", "=="])
self.wgele.activated[str].connect(self._select_threshold)
# threshold value
self.wthreshold = QLineEdit(self)
self.wthreshold.editingFinished.connect(self._select_threshold)
lo1.addWidget(self.wthreshold, 1)
# min and max label
self.wminmax = QLabel(self)
lo.addWidget(self.wminmax)
# selection slider
lo1 = QHBoxLayout()
lo.addLayout(lo1)
self.wpercent = QSlider(self)
self.wpercent.setTracking(False)
self.wpercent.valueChanged[int].connect(self._select_percentile)
self.wpercent.sliderMoved[int].connect(
self._select_percentile_threshold)
self.wpercent.setRange(0, 100)
self.wpercent.setOrientation(Qt.Horizontal)
lo1.addWidget(self.wpercent)
self.wpercent_lbl = QLabel("0%", self)
self.wpercent_lbl.setMinimumWidth(64)
lo1.addWidget(self.wpercent_lbl)
# # hide button
# lo.addSpacing(10)
# lo2 = QHBoxLayout()
# lo.addLayout(lo2)
# lo2.setContentsMargins(0,0,0,0)
# hidebtn = QPushButton("Close",self)
# hidebtn.setMinimumWidth(128)
# QObject.connect(hidebtn,pyqtSignal("clicked()"),self.hide)
# lo2.addStretch(1)
# lo2.addWidget(hidebtn)
# lo2.addStretch(1)
# self.setMinimumWidth(384)
self._in_select_threshold = False
self._sort_index = None
self.qerrmsg = QErrorMessage(self)
def add_slider(self, name, value, min, max, callback, interval=10):
self.sliders[name] = slider = QSlider(Qt.Horizontal)
slider.setTickPosition(QSlider.TicksBothSides)
slider.setTickInterval(interval)
slider.setValue(value)
slider.setMinimum(min)
slider.setMaximum(max)
slider.valueChanged.connect(callback)
self.layout.addWidget(slider)
def _set_ui(self):
frame = QFrame()
layout = QGridLayout(frame)
self.p_layout.addWidget(frame)
for i, joint in enumerate(self.joints):
setattr(self, 'checkbox_{}'.format(joint['name']),
QCheckBox('Axis-{}'.format(i + 1)))
setattr(self, 'slider_{}'.format(joint['name']),
QSlider(Qt.Horizontal))
setattr(self, 'spinbox_{}'.format(joint['name']), QDoubleSpinBox())
checkbox = getattr(self, 'checkbox_{}'.format(joint['name']))
slider = getattr(self, 'slider_{}'.format(joint['name']))
spinbox = getattr(self, 'spinbox_{}'.format(joint['name']))
slider.setMinimum(joint['range'][0] * 10)
slider.setMaximum(joint['range'][1] * 10)
slider.setValue(joint['default'] * 10)
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
spinbox.setMinimum(joint['range'][0])
spinbox.setMaximum(joint['range'][1])
spinbox.setValue(joint['default'])
slider.mouseReleaseEvent = functools.partial(
self.set_servo_angle, index=i, source=slider.mouseReleaseEvent)
spinbox.focusOutEvent = functools.partial(
self.set_servo_angle, index=i, source=spinbox.focusOutEvent)
slider.mousePressEvent = functools.partial(
self.set_flag, index=i, source=slider.mousePressEvent)
spinbox.focusInEvent = functools.partial(
self.set_flag, index=i, source=spinbox.focusInEvent)
checkbox.mouseReleaseEvent = functools.partial(
self.set_servo_state,
servo_id=i + 1,
source=checkbox.mouseReleaseEvent)
# checkbox.stateChanged.connect(functools.partial(self.checkbox_state_changed, servo_id=i+1))
slider.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=spinbox,
scale=0.1))
spinbox.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=slider,
scale=10))
layout.addWidget(checkbox, i, 0)
layout.addWidget(slider, i, 1)
layout.addWidget(spinbox, i, 2)
def __init__(self, logger, opts, parent=None):
MainWindow.__init__(self, opts, parent)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self.setWindowTitle(__appname__ + _(' - LRF viewer'))
self.logger = logger
self.opts = opts
self.create_document()
self.spin_box_action = self.spin_box = QSpinBox()
self.tool_bar.addWidget(self.spin_box)
self.tool_bar.addSeparator()
self.slider_action = self.slider = QSlider(Qt.Orientation.Horizontal)
self.tool_bar.addWidget(self.slider)
self.tool_bar.addSeparator()
self.search = SearchBox2(self)
self.search.initialize('lrf_viewer_search_history')
self.search_action = self.tool_bar.addWidget(self.search)
self.search.search.connect(self.find)
self.action_next_page.setShortcuts([
QKeySequence.StandardKey.MoveToNextPage,
QKeySequence(Qt.Key.Key_Space)
])
self.action_previous_page.setShortcuts([
QKeySequence.StandardKey.MoveToPreviousPage,
QKeySequence(Qt.Key.Key_Backspace)
])
self.action_next_match.setShortcuts(QKeySequence.StandardKey.FindNext)
self.addAction(self.action_next_match)
self.action_next_page.triggered[(bool)].connect(self.next)
self.action_previous_page.triggered[(bool)].connect(self.previous)
self.action_back.triggered[(bool)].connect(self.back)
self.action_forward.triggered[(bool)].connect(self.forward)
self.action_next_match.triggered[(bool)].connect(self.next_match)
self.action_open_ebook.triggered[(bool)].connect(self.open_ebook)
self.action_configure.triggered[(bool)].connect(self.configure)
self.spin_box.valueChanged[(int)].connect(self.go_to_page)
self.slider.valueChanged[(int)].connect(self.go_to_page)
self.graphics_view.setRenderHint(QPainter.RenderHint.Antialiasing,
True)
self.graphics_view.setRenderHint(QPainter.RenderHint.TextAntialiasing,
True)
self.graphics_view.setRenderHint(
QPainter.RenderHint.SmoothPixmapTransform, True)
self.closed = False
def _set_ui(self):
frame = QFrame()
layout = QGridLayout(frame)
self.p_layout.addWidget(frame)
for i, cartesian in enumerate(self.cartesians):
label = QLabel('{}:'.format(cartesian['name']))
setattr(self, 'slider_{}'.format(cartesian['name']),
QSlider(Qt.Horizontal))
setattr(self, 'spinbox_{}'.format(cartesian['name']),
QDoubleSpinBox())
slider = getattr(self, 'slider_{}'.format(cartesian['name']))
spinbox = getattr(self, 'spinbox_{}'.format(cartesian['name']))
slider.setMinimum(cartesian['range'][0] * 10)
slider.setMaximum(cartesian['range'][1] * 10)
slider.setValue(cartesian['default'] * 10)
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
spinbox.setMinimum(cartesian['range'][0])
spinbox.setMaximum(cartesian['range'][1])
spinbox.setValue(cartesian['default'])
if cartesian['name'] != 'radius':
slider.mouseReleaseEvent = functools.partial(
self.set_position,
index=i,
source=slider.mouseReleaseEvent)
spinbox.focusOutEvent = functools.partial(
self.set_position, index=i, source=spinbox.focusOutEvent)
slider.mousePressEvent = functools.partial(
self.set_flag, index=i, source=slider.mousePressEvent)
spinbox.focusInEvent = functools.partial(
self.set_flag, index=i, source=spinbox.focusInEvent)
slider.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=spinbox,
scale=0.1))
spinbox.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=slider,
scale=10))
layout.addWidget(label, i, 0)
layout.addWidget(slider, i, 1)
layout.addWidget(spinbox, i, 2)
def __init__(self, tts_client, initial_backend_settings=None, parent=None):
QWidget.__init__(self, parent)
self.l = l = QFormLayout(self)
self.tts_client = tts_client
with BusyCursor():
self.voice_data = self.tts_client.get_voice_data()
self.default_system_rate = self.tts_client.default_system_rate
self.all_sound_outputs = self.tts_client.get_sound_outputs()
self.speed = s = QSlider(Qt.Orientation.Horizontal, self)
s.setMinimumWidth(200)
l.addRow(_('&Speed of speech (words per minute):'), s)
s.setRange(self.tts_client.min_rate, self.tts_client.max_rate)
s.setSingleStep(1)
s.setPageStep(2)
self.voices = v = QTableView(self)
self.voices_model = VoicesModel(self.voice_data, parent=v)
self.proxy_model = p = QSortFilterProxyModel(self)
p.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
p.setSourceModel(self.voices_model)
v.setModel(p)
v.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
v.setSortingEnabled(True)
v.horizontalHeader().resizeSection(
0,
QFontMetrics(self.font()).averageCharWidth() * 25)
v.horizontalHeader().resizeSection(
1,
QFontMetrics(self.font()).averageCharWidth() * 30)
v.verticalHeader().close()
v.verticalHeader().close()
v.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
v.sortByColumn(0, Qt.SortOrder.AscendingOrder)
l.addRow(v)
self.sound_outputs = so = QComboBox(self)
so.addItem(_('System default'), '')
for x in self.all_sound_outputs:
so.addItem(x.get('description') or x['id'], x['id'])
l.addRow(_('Sound output:'), so)
self.backend_settings = initial_backend_settings or {}
def __init__(self, tts_client, initial_backend_settings=None, parent=None):
QWidget.__init__(self, parent)
self.l = l = QFormLayout(self)
self.tts_client = tts_client
self.speed = s = QSlider(Qt.Orientation.Horizontal, self)
s.setTickPosition(QSlider.TickPosition.TicksAbove)
s.setMinimumWidth(200)
l.addRow(_('&Speed of speech:'), s)
s.setRange(self.tts_client.min_rate, self.tts_client.max_rate)
s.setSingleStep(10)
s.setTickInterval((s.maximum() - s.minimum()) // 2)
self.output_modules = om = QComboBox(self)
with BusyCursor():
self.voice_data = self.tts_client.get_voice_data()
self.system_default_output_module = self.tts_client.system_default_output_module
om.addItem(_('System default'), self.system_default_output_module)
for x in self.voice_data:
om.addItem(x, x)
l.addRow(_('Speech s&ynthesizer:'), om)
self.voices = v = QTableView(self)
self.voices_model = VoicesModel(self.voice_data,
self.system_default_output_module,
parent=v)
self.proxy_model = p = QSortFilterProxyModel(self)
p.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
p.setSourceModel(self.voices_model)
v.setModel(p)
v.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
v.setSortingEnabled(True)
v.horizontalHeader().resizeSection(
0,
QFontMetrics(self.font()).averageCharWidth() * 30)
v.verticalHeader().close()
v.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
v.sortByColumn(0, Qt.SortOrder.AscendingOrder)
om.currentIndexChanged.connect(self.output_module_changed)
l.addRow(v)
self.backend_settings = initial_backend_settings or {}
def __init__(self, tts_client, initial_backend_settings=None, parent=None):
QWidget.__init__(self, parent)
self.l = l = QFormLayout(self)
self.tts_client = tts_client
with BusyCursor():
self.voice_data = self.tts_client.get_voice_data()
self.default_system_rate = self.tts_client.default_system_rate
self.speed = s = QSlider(Qt.Orientation.Horizontal, self)
s.setMinimumWidth(200)
l.addRow(_('&Speed of speech (words per minute):'), s)
delta = self.default_system_rate - 50
s.setRange(self.default_system_rate - delta,
self.default_system_rate + delta)
s.setSingleStep(10)
self.voices = v = QTableView(self)
self.voices_model = VoicesModel(self.voice_data, parent=v)
self.proxy_model = p = QSortFilterProxyModel(self)
p.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
p.setSourceModel(self.voices_model)
v.setModel(p)
v.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
v.setSortingEnabled(True)
v.horizontalHeader().resizeSection(
0,
QFontMetrics(self.font()).averageCharWidth() * 20)
v.horizontalHeader().resizeSection(
1,
QFontMetrics(self.font()).averageCharWidth() * 30)
v.verticalHeader().close()
v.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
v.sortByColumn(0, Qt.SortOrder.AscendingOrder)
l.addRow(v)
self.backend_settings = initial_backend_settings or {}
def _set_middle_frame_ui(self):
middle_frame = QFrame()
self.middle_layout = QHBoxLayout(middle_frame)
middle_left_frame = QFrame()
# middle_left_frame.setMinimumWidth(self.main_ui.window.geometry().width() / 2 - 20)
middle_right_frame = QFrame()
# middle_right_frame.setMinimumWidth(self.main_ui.window.geometry().width() / 2 - 20)
self.middle_left_layout = QGridLayout(middle_left_frame)
self.middle_right_layout = QGridLayout(middle_right_frame)
self.middle_layout.addWidget(middle_left_frame)
self.middle_layout.addWidget(middle_right_frame)
self.layout.addWidget(middle_frame)
row = 0
self.checkbox_outline = QRadioButton('OutLine')
self.checkbox_gray = QRadioButton('Gray')
self.checkbox_gray.hide()
self.btn_load_img = QPushButton('LoadImage')
self.checkbox_outline.toggle()
self.isOutlineMode = True
self.checkbox_outline.setDisabled(True)
self.middle_left_layout.addWidget(self.checkbox_outline, row, 0)
self.middle_left_layout.addWidget(self.checkbox_gray, row, 1)
self.middle_left_layout.addWidget(self.btn_load_img, row, 2)
row += 1
label_x_home = QLabel('x_home:')
self.slider_x_home = QSlider(QtCore.Qt.Horizontal)
self.slider_x_home.setMinimum(0)
self.slider_x_home.setMaximum(2000)
self.slider_x_home.setValue(1500)
self.spinbox_x_home = QDoubleSpinBox()
self.spinbox_x_home.setDecimals(1)
self.spinbox_x_home.setSingleStep(0.1)
self.spinbox_x_home.setMinimum(0.0)
self.spinbox_x_home.setMaximum(200.0)
self.spinbox_x_home.setValue(150.0)
self.slider_x_home.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_x_home.mouseReleaseEvent)
self.spinbox_x_home.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_x_home.focusOutEvent)
self.middle_left_layout.addWidget(label_x_home, row, 0)
self.middle_left_layout.addWidget(self.slider_x_home, row, 1)
self.middle_left_layout.addWidget(self.spinbox_x_home, row, 2)
row += 1
label_y_home = QLabel('y_home:')
self.slider_y_home = QSlider(QtCore.Qt.Horizontal)
self.slider_y_home.setMinimum(-1500)
self.slider_y_home.setMaximum(1500)
self.slider_y_home.setValue(0)
self.spinbox_y_home = QDoubleSpinBox()
self.spinbox_y_home.setDecimals(1)
self.spinbox_y_home.setSingleStep(0.1)
self.spinbox_y_home.setMinimum(-150.0)
self.spinbox_y_home.setMaximum(150.0)
self.spinbox_y_home.setValue(0.0)
self.slider_y_home.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_y_home.mouseReleaseEvent)
self.spinbox_y_home.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_y_home.focusOutEvent)
self.middle_left_layout.addWidget(label_y_home, row, 0)
self.middle_left_layout.addWidget(self.slider_y_home, row, 1)
self.middle_left_layout.addWidget(self.spinbox_y_home, row, 2)
row += 1
label_z_home = QLabel('z_home:')
self.slider_z_home = QSlider(QtCore.Qt.Horizontal)
self.slider_z_home.setMinimum(0)
self.slider_z_home.setMaximum(1500)
self.slider_z_home.setValue(900)
self.spinbox_z_home = QDoubleSpinBox()
self.spinbox_z_home.setDecimals(1)
self.spinbox_z_home.setSingleStep(0.1)
self.spinbox_z_home.setMinimum(0.0)
self.spinbox_z_home.setMaximum(150.0)
self.spinbox_z_home.setValue(90.0)
self.slider_z_home.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_z_home.mouseReleaseEvent)
self.spinbox_z_home.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_z_home.focusOutEvent)
self.middle_left_layout.addWidget(label_z_home, row, 0)
self.middle_left_layout.addWidget(self.slider_z_home, row, 1)
self.middle_left_layout.addWidget(self.spinbox_z_home, row, 2)
row += 1
label_x_offset = QLabel('x_offset:')
self.slider_x_offset = QSlider(QtCore.Qt.Horizontal)
self.slider_x_offset.setMinimum(-5000)
self.slider_x_offset.setMaximum(5000)
self.slider_x_offset.setValue(0)
self.spinbox_x_offset = QDoubleSpinBox()
self.spinbox_x_offset.setSingleStep(0.1)
self.spinbox_x_offset.setDecimals(1)
self.spinbox_x_offset.setMinimum(-500.0)
self.spinbox_x_offset.setMaximum(500.0)
self.spinbox_x_offset.setValue(0.0)
self.slider_x_offset.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_x_offset.mouseReleaseEvent)
self.spinbox_x_offset.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_x_offset.focusOutEvent)
self.middle_left_layout.addWidget(label_x_offset, row, 0)
self.middle_left_layout.addWidget(self.slider_x_offset, row, 1)
self.middle_left_layout.addWidget(self.spinbox_x_offset, row, 2)
row += 1
label_y_offset = QLabel('y_offset:')
self.slider_y_offset = QSlider(QtCore.Qt.Horizontal)
self.slider_y_offset.setMinimum(-5000)
self.slider_y_offset.setMaximum(5000)
self.slider_y_offset.setValue(0)
self.spinbox_y_offset = QDoubleSpinBox()
self.spinbox_y_offset.setDecimals(1)
self.spinbox_y_offset.setSingleStep(0.1)
self.spinbox_y_offset.setMinimum(-500.0)
self.spinbox_y_offset.setMaximum(500.0)
self.spinbox_y_offset.setValue(0.0)
self.slider_y_offset.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_y_offset.mouseReleaseEvent)
self.spinbox_y_offset.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_y_offset.focusOutEvent)
self.middle_left_layout.addWidget(label_y_offset, row, 0)
self.middle_left_layout.addWidget(self.slider_y_offset, row, 1)
self.middle_left_layout.addWidget(self.spinbox_y_offset, row, 2)
row += 1
label_z_offset = QLabel('z_offset:')
self.slider_z_offset = QSlider(QtCore.Qt.Horizontal)
self.slider_z_offset.setMinimum(-1000)
self.slider_z_offset.setMaximum(1500)
self.slider_z_offset.setValue(900)
self.spinbox_z_offset = QDoubleSpinBox()
self.spinbox_z_offset.setDecimals(1)
self.spinbox_z_offset.setSingleStep(0.1)
self.spinbox_z_offset.setMinimum(-100.0)
self.spinbox_z_offset.setMaximum(150.0)
self.spinbox_z_offset.setValue(90.0)
self.slider_z_offset.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_z_offset.mouseReleaseEvent)
self.spinbox_z_offset.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_z_offset.focusOutEvent)
self.middle_left_layout.addWidget(label_z_offset, row, 0)
self.middle_left_layout.addWidget(self.slider_z_offset, row, 1)
self.middle_left_layout.addWidget(self.spinbox_z_offset, row, 2)
row += 1
label_pen_up = QLabel('pen_up:')
self.slider_pen_up = QSlider(QtCore.Qt.Horizontal)
self.slider_pen_up.setMinimum(0)
self.slider_pen_up.setMaximum(500)
self.slider_pen_up.setValue(200)
self.spinbox_pen_up = QDoubleSpinBox()
self.spinbox_pen_up.setDecimals(1)
self.spinbox_pen_up.setSingleStep(0.1)
self.spinbox_pen_up.setMinimum(0.0)
self.spinbox_pen_up.setMaximum(50.0)
self.spinbox_pen_up.setValue(20.0)
self.slider_pen_up.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_pen_up.mouseReleaseEvent)
self.spinbox_pen_up.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_pen_up.focusOutEvent)
self.slider_pen_up.setDisabled(True)
self.spinbox_pen_up.setDisabled(True)
self.middle_left_layout.addWidget(label_pen_up, row, 0)
self.middle_left_layout.addWidget(self.slider_pen_up, row, 1)
self.middle_left_layout.addWidget(self.spinbox_pen_up, row, 2)
row = 0
self.checkbox_laser = QRadioButton('Laser')
self.checkbox_pen = QRadioButton('Pen')
self.checkbox_laser.toggle()
self.isLaserMode = True
self.middle_right_layout.addWidget(self.checkbox_laser, row, 0)
self.middle_right_layout.addWidget(self.checkbox_pen, row, 1)
row += 1
label_drawing_feedrate = QLabel('drawing_feedrate:')
self.slider_drawing_feedrate = QSlider(QtCore.Qt.Horizontal)
self.slider_drawing_feedrate.setMinimum(5)
self.slider_drawing_feedrate.setMaximum(1000)
self.slider_drawing_feedrate.setValue(100)
self.spinbox_drawing_feedrate = QSpinBox()
self.spinbox_drawing_feedrate.setMinimum(5)
self.spinbox_drawing_feedrate.setMaximum(1000)
self.spinbox_drawing_feedrate.setValue(100)
self.slider_drawing_feedrate.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_drawing_feedrate.mouseReleaseEvent)
self.spinbox_drawing_feedrate.focusOutEvent = functools.partial(
self.focusOutEvent,
source=self.spinbox_drawing_feedrate.focusOutEvent)
self.middle_right_layout.addWidget(label_drawing_feedrate, row, 0)
self.middle_right_layout.addWidget(self.slider_drawing_feedrate, row,
1)
self.middle_right_layout.addWidget(self.spinbox_drawing_feedrate, row,
2)
row += 1
label_moving_feedrate = QLabel('moving_feedrate:')
self.slider_moving_feedrate = QSlider(QtCore.Qt.Horizontal)
self.slider_moving_feedrate.setMinimum(5)
self.slider_moving_feedrate.setMaximum(20000)
self.slider_moving_feedrate.setValue(100)
self.spinbox_moving_feedrate = QSpinBox()
self.spinbox_moving_feedrate.setMinimum(5)
self.spinbox_moving_feedrate.setMaximum(20000)
self.spinbox_moving_feedrate.setValue(100)
self.slider_moving_feedrate.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent,
source=self.slider_moving_feedrate.mouseReleaseEvent)
self.spinbox_moving_feedrate.focusOutEvent = functools.partial(
self.focusOutEvent,
source=self.spinbox_moving_feedrate.focusOutEvent)
self.middle_right_layout.addWidget(label_moving_feedrate, row, 0)
self.middle_right_layout.addWidget(self.slider_moving_feedrate, row, 1)
self.middle_right_layout.addWidget(self.spinbox_moving_feedrate, row,
2)
row += 1
label_scale = QLabel('scale:')
self.slider_scale = QSlider(QtCore.Qt.Horizontal)
self.slider_scale.setMinimum(1)
self.slider_scale.setMaximum(100)
self.slider_scale.setValue(10)
self.spinbox_scale = QDoubleSpinBox()
self.spinbox_scale.setDecimals(1)
self.spinbox_scale.setSingleStep(0.1)
self.spinbox_scale.setMinimum(0.1)
self.spinbox_scale.setMaximum(10.0)
self.spinbox_scale.setValue(1.0)
# self.slider_scale.setDisabled(True)
# self.spinbox_scale.setDisabled(True)
self.slider_scale.mouseReleaseEvent = functools.partial(
self.mouseReleaseEvent, source=self.slider_scale.mouseReleaseEvent)
self.spinbox_scale.focusOutEvent = functools.partial(
self.focusOutEvent, source=self.spinbox_scale.focusOutEvent)
self.middle_right_layout.addWidget(label_scale, row, 0)
self.middle_right_layout.addWidget(self.slider_scale, row, 1)
self.middle_right_layout.addWidget(self.spinbox_scale, row, 2)
row += 1
label_resolution = QLabel('resolution:')
self.slider_resolution = QSlider(QtCore.Qt.Horizontal)
self.slider_resolution.setMinimum(1)
self.slider_resolution.setMaximum(100)
self.slider_resolution.setValue(10)
self.spinbox_resolution = QDoubleSpinBox()
self.spinbox_resolution.setMinimum(0.1)
self.spinbox_resolution.setMaximum(10.0)
self.spinbox_resolution.setSingleStep(0.1)
self.spinbox_resolution.setDecimals(1)
self.spinbox_resolution.setValue(1.0)
self.slider_resolution.setDisabled(True)
self.spinbox_resolution.setDisabled(True)
self.middle_right_layout.addWidget(label_resolution, row, 0)
self.middle_right_layout.addWidget(self.slider_resolution, row, 1)
self.middle_right_layout.addWidget(self.spinbox_resolution, row, 2)
row += 1
self.btn_generate_gcode = QPushButton('Generate_Gcode')
self.middle_right_layout.addWidget(self.btn_generate_gcode, row, 0)
row += 1
self.label_x_min = QLabel('')
self.label_x_max = QLabel('')
self.middle_right_layout.addWidget(self.label_x_min, row, 0)
self.middle_right_layout.addWidget(self.label_x_max, row, 1)
row += 1
self.label_y_min = QLabel('')
self.label_y_max = QLabel('')
self.middle_right_layout.addWidget(self.label_y_min, row, 0)
self.middle_right_layout.addWidget(self.label_y_max, row, 1)
def __init__(self, window, plugin, keystore, device_id):
title = _("{} Settings").format(plugin.device)
super(SettingsDialog, self).__init__(window, title)
self.setMaximumWidth(540)
devmgr = plugin.device_manager()
config = devmgr.config
handler = keystore.handler
thread = keystore.thread
hs_rows, hs_cols = (64, 128)
def invoke_client(method, *args, **kw_args):
unpair_after = kw_args.pop('unpair_after', False)
def task():
client = devmgr.client_by_id(device_id)
if not client:
raise RuntimeError("Device not connected")
if method:
getattr(client, method)(*args, **kw_args)
if unpair_after:
devmgr.unpair_id(device_id)
return client.features
thread.add(task, on_success=update)
def update(features):
self.features = features
set_label_enabled()
if features.bootloader_hash:
bl_hash = bh2u(features.bootloader_hash)
bl_hash = "\n".join([bl_hash[:32], bl_hash[32:]])
else:
bl_hash = "N/A"
noyes = [_("No"), _("Yes")]
endis = [_("Enable Passphrases"), _("Disable Passphrases")]
disen = [_("Disabled"), _("Enabled")]
setchange = [_("Set a PIN"), _("Change PIN")]
version = "%d.%d.%d" % (features.major_version,
features.minor_version,
features.patch_version)
device_label.setText(features.label)
pin_set_label.setText(noyes[features.pin_protection])
passphrases_label.setText(disen[features.passphrase_protection])
bl_hash_label.setText(bl_hash)
label_edit.setText(features.label)
device_id_label.setText(features.device_id)
initialized_label.setText(noyes[features.initialized])
version_label.setText(version)
clear_pin_button.setVisible(features.pin_protection)
clear_pin_warning.setVisible(features.pin_protection)
pin_button.setText(setchange[features.pin_protection])
pin_msg.setVisible(not features.pin_protection)
passphrase_button.setText(endis[features.passphrase_protection])
language_label.setText(features.language)
def set_label_enabled():
label_apply.setEnabled(label_edit.text() != self.features.label)
def rename():
invoke_client('change_label', label_edit.text())
def toggle_passphrase():
title = _("Confirm Toggle Passphrase Protection")
currently_enabled = self.features.passphrase_protection
if currently_enabled:
msg = _("After disabling passphrases, you can only pair this "
"Electrum wallet if it had an empty passphrase. "
"If its passphrase was not empty, you will need to "
"create a new wallet with the install wizard. You "
"can use this wallet again at any time by re-enabling "
"passphrases and entering its passphrase.")
else:
msg = _("Your current Electrum wallet can only be used with "
"an empty passphrase. You must create a separate "
"wallet with the install wizard for other passphrases "
"as each one generates a new set of addresses.")
msg += "\n\n" + _("Are you sure you want to proceed?")
if not self.question(msg, title=title):
return
invoke_client('toggle_passphrase', unpair_after=currently_enabled)
def change_homescreen():
dialog = QFileDialog(self, _("Choose Homescreen"))
filename, __ = dialog.getOpenFileName()
if not filename:
return # user cancelled
if filename.endswith('.toif'):
img = open(filename, 'rb').read()
if img[:8] != b'TOIf\x90\x00\x90\x00':
handler.show_error('File is not a TOIF file with size of \
144x144')
return
else:
from PIL import Image # FIXME
im = Image.open(filename)
if im.size != (128, 64):
handler.show_error('Image must be 128 x 64 pixels')
return
im = im.convert('1')
pix = im.load()
img = bytearray(1024)
for j in range(64):
for i in range(128):
if pix[i, j]:
o = (i + j * 128)
img[o // 8] |= (1 << (7 - o % 8))
img = bytes(img)
invoke_client('change_homescreen', img)
def clear_homescreen():
invoke_client('change_homescreen', b'\x00')
def set_pin():
invoke_client('set_pin', remove=False)
def clear_pin():
invoke_client('set_pin', remove=True)
def wipe_device():
wallet = window.wallet
if wallet and sum(wallet.get_balance()):
title = _("Confirm Device Wipe")
msg = _("Are you SURE you want to wipe the device?\n"
"Your wallet still has bitcoins in it!")
if not self.question(
msg, title=title, icon=QMessageBox.Critical):
return
invoke_client('wipe_device', unpair_after=True)
def slider_moved():
mins = timeout_slider.sliderPosition()
timeout_minutes.setText(_("%2d minutes") % mins)
def slider_released():
config.set_session_timeout(timeout_slider.sliderPosition() * 60)
# Information tab
info_tab = QWidget()
info_layout = QVBoxLayout(info_tab)
info_glayout = QGridLayout()
info_glayout.setColumnStretch(2, 1)
device_label = QLabel()
pin_set_label = QLabel()
passphrases_label = QLabel()
version_label = QLabel()
device_id_label = QLabel()
bl_hash_label = QLabel()
bl_hash_label.setWordWrap(True)
language_label = QLabel()
initialized_label = QLabel()
rows = [
(_("Device Label"), device_label),
(_("PIN set"), pin_set_label),
(_("Passphrases"), passphrases_label),
(_("Firmware Version"), version_label),
(_("Device ID"), device_id_label),
(_("Bootloader Hash"), bl_hash_label),
(_("Language"), language_label),
(_("Initialized"), initialized_label),
]
for row_num, (label, widget) in enumerate(rows):
info_glayout.addWidget(QLabel(label), row_num, 0)
info_glayout.addWidget(widget, row_num, 1)
info_layout.addLayout(info_glayout)
# Settings tab
settings_tab = QWidget()
settings_layout = QVBoxLayout(settings_tab)
settings_glayout = QGridLayout()
# Settings tab - Label
label_msg = QLabel(
_("Name this {}. If you have multiple devices "
"their labels help distinguish them.").format(plugin.device))
label_msg.setWordWrap(True)
label_label = QLabel(_("Device Label"))
label_edit = QLineEdit()
label_edit.setMinimumWidth(150)
label_edit.setMaxLength(plugin.MAX_LABEL_LEN)
label_apply = QPushButton(_("Apply"))
label_apply.clicked.connect(rename)
label_edit.textChanged.connect(set_label_enabled)
settings_glayout.addWidget(label_label, 0, 0)
settings_glayout.addWidget(label_edit, 0, 1, 1, 2)
settings_glayout.addWidget(label_apply, 0, 3)
settings_glayout.addWidget(label_msg, 1, 1, 1, -1)
pin_button = QPushButton()
# Settings tab - PIN
pin_label = QLabel(_("PIN Protection"))
pin_button.clicked.connect(set_pin)
settings_glayout.addWidget(pin_label, 2, 0)
settings_glayout.addWidget(pin_button, 2, 1)
pin_msg = QLabel(
_("PIN protection is strongly recommended. "
"A PIN is your only protection against someone "
"stealing your bitcoins if they obtain physical "
"access to your {}.").format(plugin.device))
pin_msg.setWordWrap(True)
pin_msg.setStyleSheet("color: red")
settings_glayout.addWidget(pin_msg, 3, 1, 1, -1)
# Settings tab - Homescreen
homescreen_label = QLabel(_("Homescreen"))
homescreen_change_button = QPushButton(_("Change..."))
homescreen_clear_button = QPushButton(_("Reset"))
homescreen_change_button.clicked.connect(change_homescreen)
try:
import PIL
except ImportError:
homescreen_change_button.setDisabled(True)
homescreen_change_button.setToolTip(
_("Required package 'PIL' is not available - Please install \
it or use the OctoWallet website instead."))
homescreen_clear_button.clicked.connect(clear_homescreen)
homescreen_msg = QLabel(
_("You can set the homescreen on your "
"device to personalize it. You must "
"choose a {} x {} monochrome black and "
"white image.").format(hs_rows, hs_cols))
homescreen_msg.setWordWrap(True)
settings_glayout.addWidget(homescreen_label, 4, 0)
settings_glayout.addWidget(homescreen_change_button, 4, 1)
settings_glayout.addWidget(homescreen_clear_button, 4, 2)
settings_glayout.addWidget(homescreen_msg, 5, 1, 1, -1)
# Settings tab - Session Timeout
timeout_label = QLabel(_("Session Timeout"))
timeout_minutes = QLabel()
timeout_slider = QSlider(Qt.Horizontal)
timeout_slider.setRange(1, 60)
timeout_slider.setSingleStep(1)
timeout_slider.setTickInterval(5)
timeout_slider.setTickPosition(QSlider.TicksBelow)
timeout_slider.setTracking(True)
timeout_msg = QLabel(
_("Clear the session after the specified period "
"of inactivity. Once a session has timed out, "
"your PIN and passphrase (if enabled) must be "
"re-entered to use the device."))
timeout_msg.setWordWrap(True)
timeout_slider.setSliderPosition(config.get_session_timeout() // 60)
slider_moved()
timeout_slider.valueChanged.connect(slider_moved)
timeout_slider.sliderReleased.connect(slider_released)
settings_glayout.addWidget(timeout_label, 6, 0)
settings_glayout.addWidget(timeout_slider, 6, 1, 1, 3)
settings_glayout.addWidget(timeout_minutes, 6, 4)
settings_glayout.addWidget(timeout_msg, 7, 1, 1, -1)
settings_layout.addLayout(settings_glayout)
settings_layout.addStretch(1)
# Advanced tab
advanced_tab = QWidget()
advanced_layout = QVBoxLayout(advanced_tab)
advanced_glayout = QGridLayout()
# Advanced tab - clear PIN
clear_pin_button = QPushButton(_("Disable PIN"))
clear_pin_button.clicked.connect(clear_pin)
clear_pin_warning = QLabel(
_("If you disable your PIN, anyone with physical access to your "
"{} device can spend your bitcoins.").format(plugin.device))
clear_pin_warning.setWordWrap(True)
clear_pin_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(clear_pin_button, 0, 2)
advanced_glayout.addWidget(clear_pin_warning, 1, 0, 1, 5)
# Advanced tab - toggle passphrase protection
passphrase_button = QPushButton()
passphrase_button.clicked.connect(toggle_passphrase)
passphrase_msg = WWLabel(PASSPHRASE_HELP)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(passphrase_button, 3, 2)
advanced_glayout.addWidget(passphrase_msg, 4, 0, 1, 5)
advanced_glayout.addWidget(passphrase_warning, 5, 0, 1, 5)
# Advanced tab - wipe device
wipe_device_button = QPushButton(_("Wipe Device"))
wipe_device_button.clicked.connect(wipe_device)
wipe_device_msg = QLabel(
_("Wipe the device, removing all data from it. The firmware "
"is left unchanged."))
wipe_device_msg.setWordWrap(True)
wipe_device_warning = QLabel(
_("Only wipe a device if you have the recovery seed written down "
"and the device wallet(s) are empty, otherwise the bitcoins "
"will be lost forever."))
wipe_device_warning.setWordWrap(True)
wipe_device_warning.setStyleSheet("color: red")
advanced_glayout.addWidget(wipe_device_button, 6, 2)
advanced_glayout.addWidget(wipe_device_msg, 7, 0, 1, 5)
advanced_glayout.addWidget(wipe_device_warning, 8, 0, 1, 5)
advanced_layout.addLayout(advanced_glayout)
advanced_layout.addStretch(1)
tabs = QTabWidget(self)
tabs.addTab(info_tab, _("Information"))
tabs.addTab(settings_tab, _("Settings"))
tabs.addTab(advanced_tab, _("Advanced"))
dialog_vbox = QVBoxLayout(self)
dialog_vbox.addWidget(tabs)
dialog_vbox.addLayout(Buttons(CloseButton(self)))
# Update information
invoke_client(None)
def _set_common_down_ui(self):
slider_frame = QFrame()
slider_layout = QGridLayout(slider_frame)
self.layout.addWidget(slider_frame)
label = QLabel(i18n[self.lang]['Speed'] + ':')
self.slider_speed = QSlider(Qt.Horizontal)
self.spinbox_speed = QSpinBox()
self.slider_speed.setMinimum(1)
self.slider_speed.setMaximum(1000)
self.slider_speed.setValue(50)
self.spinbox_speed.setSingleStep(1)
self.spinbox_speed.setMinimum(1)
self.spinbox_speed.setMaximum(1000)
self.spinbox_speed.setValue(50)
slider_layout.addWidget(label, 0, 0)
slider_layout.addWidget(self.slider_speed, 0, 1)
slider_layout.addWidget(self.spinbox_speed, 0, 2)
label = QLabel(i18n[self.lang]['Acc'] + ':')
self.slider_acc = QSlider(Qt.Horizontal)
self.spinbox_acc = QSpinBox()
self.slider_acc.setMinimum(1)
self.slider_acc.setMaximum(100000)
self.slider_acc.setValue(5000)
self.spinbox_acc.setSingleStep(1)
self.spinbox_acc.setMinimum(1)
self.spinbox_acc.setMaximum(100000)
self.spinbox_acc.setValue(5000)
slider_layout.addWidget(label, 0, 3)
slider_layout.addWidget(self.slider_acc, 0, 4)
slider_layout.addWidget(self.spinbox_acc, 0, 5)
common_frame = QFrame()
common_layout = QGridLayout(common_frame)
self.layout.addWidget(common_frame)
self.btn_stop = QPushButton(i18n[self.lang]['Stop'])
self.btn_clean = QPushButton(i18n[self.lang]['CleanErrorWarn'])
self.btn_reset = QPushButton(i18n[self.lang]['Reset'])
self.btn_get_servo_dbmsg = QPushButton(
i18n[self.lang]['GetServoDebugMsg'])
common_layout.addWidget(self.btn_stop, 0, 0)
common_layout.addWidget(self.btn_clean, 0, 2)
common_layout.addWidget(self.btn_reset, 0, 3)
common_layout.addWidget(self.btn_get_servo_dbmsg, 0, 4)
btn_frame = QFrame()
btn_layout = QGridLayout(btn_frame)
self.layout.addWidget(btn_frame)
self.combobox_servo = QComboBox()
self.combobox_servo.setStyleSheet('''color: blue;''')
for item in [
'axis-all', 'axis-1', 'axis-2', 'axis-3', 'axis-4', 'axis-5',
'axis-6', 'axis-7'
]:
self.combobox_servo.addItem(item)
self.combobox_servo.setCurrentIndex(1)
btn_layout.addWidget(self.combobox_servo, 0, 0)
self.btn_motion_enable = QPushButton(i18n[self.lang]['MotionEnable'])
self.btn_motion_disable = QPushButton(i18n[self.lang]['MotionDisable'])
self.btn_servo_attach = QPushButton(i18n[self.lang]['ServoAttach'])
self.btn_servo_detach = QPushButton(i18n[self.lang]['ServoDetach'])
self.combobox_state = QComboBox()
self.combobox_state.setStyleSheet('''color: blue;''')
for item in ['sport', 'pause', 'stop']:
self.combobox_state.addItem(item)
self.combobox_state.setCurrentIndex(0)
self.btn_set_state = QPushButton(i18n[self.lang]['SetState'])
btn_layout.addWidget(self.btn_motion_enable, 0, 1)
btn_layout.addWidget(self.btn_motion_disable, 0, 2)
btn_layout.addWidget(self.btn_servo_attach, 0, 3)
btn_layout.addWidget(self.btn_servo_detach, 0, 4)
btn_layout.addWidget(self.combobox_state, 0, 5)
btn_layout.addWidget(self.btn_set_state, 0, 6)
self.lnt_servo_addr = QLineEdit('servo_addr')
self.lnt_servo_addr_value = QLineEdit('value')
self.btn_get_servo_addr16 = QPushButton(
i18n[self.lang]['GetServoAddr16'])
self.btn_set_servo_addr16 = QPushButton(
i18n[self.lang]['SetServoAddr16'])
self.btn_get_servo_addr32 = QPushButton(
i18n[self.lang]['GetServoAddr32'])
self.btn_set_servo_addr32 = QPushButton(
i18n[self.lang]['SetServoAddr32'])
self.btn_set_servo_zero = QPushButton(i18n[self.lang]['SetServoZero'])
btn_layout.addWidget(self.lnt_servo_addr, 1, 0)
btn_layout.addWidget(self.lnt_servo_addr_value, 1, 1)
btn_layout.addWidget(self.btn_get_servo_addr16, 1, 2)
btn_layout.addWidget(self.btn_set_servo_addr16, 1, 3)
btn_layout.addWidget(self.btn_get_servo_addr32, 1, 4)
btn_layout.addWidget(self.btn_set_servo_addr32, 1, 5)
btn_layout.addWidget(self.btn_set_servo_zero, 1, 6)
def _set_common_down_ui(self):
slider_frame = QFrame()
slider_layout = QGridLayout(slider_frame)
self.layout.addWidget(slider_frame)
label = QLabel(i18n[self.lang]['Speed'] + ':')
self.slider_speed = QSlider(Qt.Horizontal)
self.spinbox_speed = QSpinBox()
self.slider_speed.setMinimum(1)
self.slider_speed.setMaximum(100000)
self.slider_speed.setValue(10000)
self.spinbox_speed.setSingleStep(1)
self.spinbox_speed.setMinimum(1)
self.spinbox_speed.setMaximum(100000)
self.spinbox_speed.setValue(10000)
slider_layout.addWidget(label, 0, 0)
slider_layout.addWidget(self.slider_speed, 0, 1)
slider_layout.addWidget(self.spinbox_speed, 0, 2)
# label = QLabel(i18n[self.lang]['Acc'] + ':')
# self.slider_acc = QSlider(Qt.Horizontal)
# self.spinbox_acc = QSpinBox()
# self.slider_acc.setMinimum(1)
# self.slider_acc.setMaximum(100000)
# self.slider_acc.setValue(5000)
# self.spinbox_acc.setSingleStep(1)
# self.spinbox_acc.setMinimum(1)
# self.spinbox_acc.setMaximum(100000)
# self.spinbox_acc.setValue(5000)
# slider_layout.addWidget(label, 0, 3)
# slider_layout.addWidget(self.slider_acc, 0, 4)
# slider_layout.addWidget(self.spinbox_acc, 0, 5)
btn_frame = QFrame()
btn_layout = QGridLayout(btn_frame)
self.layout.addWidget(btn_frame)
self.btn_get_device_info = QPushButton(i18n[self.lang]['GetDeviceInfo'])
self.btn_get_position = QPushButton(i18n[self.lang]['GetPosition'])
self.btn_get_polar = QPushButton(i18n[self.lang]['GetPolar'])
self.btn_get_servo_angle = QPushButton(i18n[self.lang]['GetServoAngle'])
self.btn_get_mode = QPushButton(i18n[self.lang]['GetMode'])
btn_layout.addWidget(self.btn_get_device_info, 0, 0)
btn_layout.addWidget(self.btn_get_position, 0, 1)
btn_layout.addWidget(self.btn_get_polar, 0, 2)
btn_layout.addWidget(self.btn_get_servo_angle, 0, 3)
btn_layout.addWidget(self.btn_get_mode, 0, 4)
self.combobox_servo = QComboBox()
self.combobox_servo.setStyleSheet('''color: blue;''')
for item in ['axis-1', 'axis-2', 'axis-3', 'axis-all']:
self.combobox_servo.addItem(item)
self.combobox_servo.setCurrentIndex(0)
btn_layout.addWidget(self.combobox_servo, 0, 0)
self.btn_servo_attach = QPushButton(i18n[self.lang]['ServoAttach'])
self.btn_servo_detach = QPushButton(i18n[self.lang]['ServoDetach'])
self.combobox_mode = QComboBox()
self.combobox_mode.setStyleSheet('''color: blue;''')
for item in ['normal', 'laser', '3D', 'pen']:
self.combobox_mode.addItem(item)
self.combobox_mode.setCurrentIndex(0)
self.btn_set_mode = QPushButton(i18n[self.lang]['SetMode'])
btn_layout.addWidget(self.combobox_servo, 1, 0)
btn_layout.addWidget(self.btn_servo_attach, 1, 1)
btn_layout.addWidget(self.btn_servo_detach, 1, 2)
btn_layout.addWidget(self.combobox_mode, 1, 3)
btn_layout.addWidget(self.btn_set_mode, 1, 4)
self.btn_reset = QPushButton(i18n[self.lang]['Reset'])
self.btn_pump_on = QPushButton(i18n[self.lang]['PumpOn'])
self.btn_pump_off = QPushButton(i18n[self.lang]['PumpOff'])
self.btn_gripper_catch = QPushButton(i18n[self.lang]['GripperCatch'])
self.btn_gripper_release = QPushButton(i18n[self.lang]['GripperRelease'])
btn_layout.addWidget(self.btn_reset, 2, 0)
btn_layout.addWidget(self.btn_pump_on, 2, 1)
btn_layout.addWidget(self.btn_pump_off, 2, 2)
btn_layout.addWidget(self.btn_gripper_catch, 2, 3)
btn_layout.addWidget(self.btn_gripper_release, 2, 4)
def _init_ui(self):
self.statusBar().showMessage('Ready')
# ------- FILE MENU
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
impMenu = QMenu('Import', self)
impAct = QAction('Import obj', self)
impMenu.addAction(impAct)
newAct = QAction('New', self)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
# ------- Icon exit and animate
exitAct = QAction(
QIcon('models/icon_exit.png'),
'Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.triggered.connect(qApp.quit)
animationButton = QAction(
QIcon('models/icon_play.png'),
'Animate', self)
animationButton.setShortcut('Space')
animationButton.triggered.connect(self._animate)
# self.action.setShortcut("ESC")
# ------- Display slider value
lcdAperture = QLCDNumber(self)
lcdFocalLength = QLCDNumber(self)
# lcdNear = QLCDNumber(self)
lcdFar = QLCDNumber(self)
# ------- Slider creation and connection to lcd
self.sldAperture = QSlider(Qt.Horizontal, self)
self.sldAperture.setTickPosition(QSlider.TicksBothSides)
self.sldFocalLength = QSlider(Qt.Horizontal, self)
self.sldFocalLength.setTickPosition(QSlider.TicksBothSides)
'''
self.sldNear = QSlider(Qt.Horizontal, self)
self.sldNear.setTickPosition(QSlider.TicksBothSides)
'''
self.sldFar = QSlider(Qt.Horizontal, self)
self.sldFar.setTickPosition(QSlider.TicksBothSides)
# ------- Connect slider to lcd
self.sldAperture.valueChanged.connect(lcdAperture.display)
self.sldFocalLength.valueChanged.connect(lcdFocalLength.display)
'''
self.sldNear.valueChanged.connect(lcdNear.display)
'''
self.sldFar.valueChanged.connect(lcdFar.display)
# ------- Slider parameter and specifications
# self.sldAperture.setMinimum(0)
# self.sldAperture.setMaximum(80)
self.sldAperture.setValue(sC.aperture)
self.sldAperture.setRange(10, 100)
self.sldFocalLength.setValue(sC.focalLength)
self.sldFocalLength.setRange(1, 15)
self.sldFocalLength.valueChanged.connect(self._valueHandler)
'''
self.sldNear.setValue(sC.near)
self.sldNear.setRange(0,10)
self.sldNear.valueChanged.connect(self._valueHandler)
'''
self.sldFar.setValue(sC.far)
self.sldFar.setRange(50, 150)
# ------- Show slide bar
self.exitToolbar = self.addToolBar('exit')
self.exitToolbar.addAction(exitAct)
self.exitToolbar.addAction(animationButton)
# ------- Go back to line
self.addToolBarBreak()
self.lcdToolbar = self.addToolBar('lcd')
self.lcdToolbar.addWidget(lcdAperture)
self.apertureToolbar = self.addToolBar('aperture')
self.apertureToolbar.addWidget(self.sldAperture)
self.apertureToolbar.addWidget(QLabel("Aperture"))
self.addToolBarBreak()
self.lcdToolbar2 = self.addToolBar('lcd2')
self.lcdToolbar2.addWidget(lcdFocalLength)
self.focalLengthToolbar = self.addToolBar('focalLength')
self.focalLengthToolbar.addWidget(self.sldFocalLength)
self.focalLengthToolbar.addWidget(QLabel("focalLength *100"))
self.addToolBarBreak()
'''
self.lcdToolbarNear = self.addToolBar('lcd2')
self.lcdToolbarNear.addWidget(lcdNear)
self.nearToolbar = self.addToolBar('near')
self.nearToolbar.addWidget(self.sldNear)
self.nearToolbar.addWidget(QLabel("near(/100)"))
self.addToolBarBreak()
'''
self.lcdToolbarFar = self.addToolBar('lcdFar')
self.lcdToolbarFar.addWidget(lcdFar)
self.farToolbar = self.addToolBar('far')
self.farToolbar.addWidget(self.sldFar)
self.farToolbar.addWidget(QLabel("far"))
# ------- required to display
self.setGeometry(600, 600, 600, 600)
self.show()
