def setup_ui(self):
self.l = l = QFormLayout(self)
l.addRow(
QLabel(_('Print %s to a PDF file') % elided_text(self.book_title)))
self.h = h = QHBoxLayout()
self.file_name = f = QLineEdit(self)
val = dynamic.get(self.OUTPUT_NAME, None)
if not val:
val = expanduser('~')
else:
val = os.path.dirname(val)
f.setText(os.path.abspath(os.path.join(val, self.default_file_name)))
self.browse_button = b = QToolButton(self)
b.setIcon(QIcon(I('document_open.png'))), b.setToolTip(
_('Choose location for PDF file'))
b.clicked.connect(self.choose_file)
h.addWidget(f), h.addWidget(b)
f.setMinimumWidth(350)
w = QLabel(_('&File:'))
l.addRow(w, h), w.setBuddy(f)
self.paper_size = ps = QComboBox(self)
ps.addItems([
a.upper()
for a in sorted(self.paper_size_map, key=numeric_sort_key)
])
previous_size = vprefs.get('print-to-pdf-page-size', None)
if previous_size not in self.paper_size_map:
previous_size = (QPrinter().pageLayout().pageSize().name()
or '').lower()
if previous_size not in self.paper_size_map:
previous_size = 'a4'
ps.setCurrentIndex(ps.findText(previous_size.upper()))
l.addRow(_('Paper &size:'), ps)
tmap = {
'left': _('&Left margin:'),
'top': _('&Top margin:'),
'right': _('&Right margin:'),
'bottom': _('&Bottom margin:'),
}
for edge in 'left top right bottom'.split():
m = QDoubleSpinBox(self)
m.setSuffix(' ' + _('inches'))
m.setMinimum(0), m.setMaximum(3), m.setSingleStep(0.1)
val = vprefs.get('print-to-pdf-%s-margin' % edge, 1)
m.setValue(val)
setattr(self, '%s_margin' % edge, m)
l.addRow(tmap[edge], m)
self.pnum = pnum = QCheckBox(_('Add page &number to printed pages'),
self)
pnum.setChecked(vprefs.get('print-to-pdf-page-numbers', True))
l.addRow(pnum)
self.show_file = sf = QCheckBox(_('&Open PDF file after printing'),
self)
sf.setChecked(vprefs.get('print-to-pdf-show-file', True))
l.addRow(sf)
l.addRow(self.bb)
def setup_ui(self):
self.vl = vl = QVBoxLayout(self)
self.l = l = QFormLayout()
vl.addLayout(l)
l.setContentsMargins(0, 0, 0, 0)
l.addRow(
QLabel(_('Print %s to a PDF file') % elided_text(self.book_title)))
self.h = h = QHBoxLayout()
self.file_name = f = QLineEdit(self)
val = dynamic.get(self.OUTPUT_NAME, None)
if not val:
val = expanduser('~')
else:
val = os.path.dirname(val)
f.setText(os.path.abspath(os.path.join(val, self.default_file_name)))
self.browse_button = b = QToolButton(self)
b.setIcon(QIcon(I('document_open.png'))), b.setToolTip(
_('Choose location for PDF file'))
b.clicked.connect(self.choose_file)
h.addWidget(f), h.addWidget(b)
f.setMinimumWidth(350)
w = QLabel(_('&File:'))
l.addRow(w, h), w.setBuddy(f)
self.paper_size = ps = PaperSizes(self)
ps.initialize()
ps.set_value_for_config = vprefs.get('print-to-pdf-page-size', None)
l.addRow(_('Paper &size:'), ps)
tmap = {
'left': _('&Left margin:'),
'top': _('&Top margin:'),
'right': _('&Right margin:'),
'bottom': _('&Bottom margin:'),
}
for edge in 'left top right bottom'.split():
m = QDoubleSpinBox(self)
m.setSuffix(' ' + _('inches'))
m.setMinimum(0), m.setMaximum(3), m.setSingleStep(0.1)
val = vprefs.get('print-to-pdf-%s-margin' % edge, 1)
m.setValue(val)
setattr(self, '%s_margin' % edge, m)
l.addRow(tmap[edge], m)
self.pnum = pnum = QCheckBox(_('Add page &number to printed pages'),
self)
pnum.setChecked(vprefs.get('print-to-pdf-page-numbers', True))
l.addRow(pnum)
self.show_file = sf = QCheckBox(_('&Open PDF file after printing'),
self)
sf.setChecked(vprefs.get('print-to-pdf-show-file', True))
l.addRow(sf)
vl.addStretch(10)
vl.addWidget(self.bb)
class EveryXDays(Base):
HELP = _('''\
Download this periodical every x days. For example, if you
choose 30 days, the periodical will be downloaded every 30
days. Note that you can set periods of less than a day, like
0.1 days to download a periodical more than once a day.
''')
def __init__(self, parent=None):
Base.__init__(self, parent)
self.l1 = QLabel(_('&Download every:'))
self.interval = QDoubleSpinBox(self)
self.interval.setMinimum(0.04)
self.interval.setSpecialValueText(_('every hour'))
self.interval.setMaximum(1000.0)
self.interval.setValue(31.0)
self.interval.setSuffix(' ' + _('days'))
self.interval.setSingleStep(1.0)
self.interval.setDecimals(2)
self.l1.setBuddy(self.interval)
self.l2 = QLabel(
_('Note: You can set intervals of less than a day,'
' by typing the value manually.'))
self.l2.setWordWrap(True)
self.l.addWidget(self.l1, 0, 0, 1, 1)
self.l.addWidget(self.interval, 0, 1, 1, 1)
self.l.addWidget(self.l2, 1, 0, 1, -1)
def initialize(self, typ=None, val=None):
if val is None:
val = 31.0
self.interval.setValue(val)
@property
def schedule(self):
schedule = self.interval.value()
return 'interval', schedule
class EveryXDays(Base):
HELP = _('''\
Download this periodical every x days. For example, if you
choose 30 days, the periodical will be downloaded every 30
days. Note that you can set periods of less than a day, like
0.1 days to download a periodical more than once a day.
''')
def __init__(self, parent=None):
Base.__init__(self, parent)
self.l1 = QLabel(_('&Download every:'))
self.interval = QDoubleSpinBox(self)
self.interval.setMinimum(0.04)
self.interval.setSpecialValueText(_('every hour'))
self.interval.setMaximum(1000.0)
self.interval.setValue(31.0)
self.interval.setSuffix(' ' + _('days'))
self.interval.setSingleStep(1.0)
self.interval.setDecimals(2)
self.l1.setBuddy(self.interval)
self.l2 = QLabel(
_('Note: You can set intervals of less than a day,'
' by typing the value manually.'))
self.l2.setWordWrap(True)
self.l.addWidget(self.l1, 0, 0, 1, 1)
self.l.addWidget(self.interval, 0, 1, 1, 1)
self.l.addWidget(self.l2, 1, 0, 1, -1)
def initialize(self, typ=None, val=None):
if val is None:
val = 31.0
self.interval.setValue(val)
@property
def schedule(self):
schedule = self.interval.value()
return 'interval', schedule
def setup_ui(self):
self.l = l = QFormLayout(self)
l.addRow(QLabel(_('Print %s to a PDF file') % elided_text(self.book_title)))
self.h = h = QHBoxLayout()
self.file_name = f = QLineEdit(self)
val = dynamic.get(self.OUTPUT_NAME, None)
if not val:
val = expanduser('~')
else:
val = os.path.dirname(val)
f.setText(os.path.abspath(os.path.join(val, self.default_file_name)))
self.browse_button = b = QToolButton(self)
b.setIcon(QIcon(I('document_open.png'))), b.setToolTip(_('Choose location for PDF file'))
b.clicked.connect(self.choose_file)
h.addWidget(f), h.addWidget(b)
f.setMinimumWidth(350)
w = QLabel(_('&File:'))
l.addRow(w, h), w.setBuddy(f)
self.paper_size = ps = QComboBox(self)
ps.addItems([a.upper() for a in sorted(self.paper_size_map, key=numeric_sort_key)])
previous_size = vprefs.get('print-to-pdf-page-size', None)
if previous_size not in self.paper_size_map:
previous_size = (QPrinter().pageLayout().pageSize().name() or '').lower()
if previous_size not in self.paper_size_map:
previous_size = 'a4'
ps.setCurrentIndex(ps.findText(previous_size.upper()))
l.addRow(_('Paper &size:'), ps)
tmap = {
'left':_('&Left margin:'),
'top':_('&Top margin:'),
'right':_('&Right margin:'),
'bottom':_('&Bottom margin:'),
}
for edge in 'left top right bottom'.split():
m = QDoubleSpinBox(self)
m.setSuffix(' ' + _('inches'))
m.setMinimum(0), m.setMaximum(3), m.setSingleStep(0.1)
val = vprefs.get('print-to-pdf-%s-margin' % edge, 1)
m.setValue(val)
setattr(self, '%s_margin' % edge, m)
l.addRow(tmap[edge], m)
self.pnum = pnum = QCheckBox(_('Add page &number to printed pages'), self)
pnum.setChecked(vprefs.get('print-to-pdf-page-numbers', True))
l.addRow(pnum)
self.show_file = sf = QCheckBox(_('Open PDF file after printing'), self)
sf.setChecked(vprefs.get('print-to-pdf-show-file', True))
l.addRow(sf)
l.addRow(self.bb)
class TabRewards_gui(QWidget):
def __init__(self, *args, **kwargs):
QWidget.__init__(self)
self.initRewardsForm()
mainVertical = QVBoxLayout()
mainVertical.addWidget(self.rewardsForm)
buttonbox = QHBoxLayout()
buttonbox.addStretch(1)
buttonbox.addWidget(self.btn_Cancel)
mainVertical.addLayout(buttonbox)
self.setLayout(mainVertical)
def initRewardsForm(self):
self.collateralHidden = True
self.rewardsForm = QGroupBox()
self.rewardsForm.setTitle("Transfer Rewards")
layout = QFormLayout()
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(13)
layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
##--- ROW 1
hBox = QHBoxLayout()
self.mnSelect = QComboBox()
self.mnSelect.setToolTip("Select Masternode")
hBox.addWidget(self.mnSelect)
label = QLabel("Total Address Balance")
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
hBox.addWidget(label)
self.addrAvailLine = QLabel()
self.addrAvailLine.setToolTip("PIVX Address total balance")
self.addrAvailLine.setText("--")
hBox.addWidget(self.addrAvailLine)
self.btn_toggleCollateral = QPushButton("Show Collateral")
hBox.addWidget(self.btn_toggleCollateral)
hBox.setStretch(0, 1)
hBox.setStretch(1, 0)
hBox.setStretch(2, 0)
layout.addRow(QLabel("Masternode"), hBox)
## --- ROW 2: REWARDS
self.rewardsList = QVBoxLayout()
self.rewardsList.statusLabel = QLabel(
'<b style="color:purple">Checking explorer...</b>')
self.rewardsList.statusLabel.setVisible(True)
self.rewardsList.addWidget(self.rewardsList.statusLabel)
self.rewardsList.box = QTableWidget()
self.rewardsList.box.setMinimumHeight(140)
self.rewardsList.box.setMaximumHeight(140)
self.rewardsList.box.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.rewardsList.box.setSelectionMode(QAbstractItemView.MultiSelection)
self.rewardsList.box.setSelectionBehavior(QAbstractItemView.SelectRows)
self.rewardsList.box.setShowGrid(True)
self.rewardsList.box.setColumnCount(4)
self.rewardsList.box.setRowCount(0)
self.rewardsList.box.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.rewardsList.box.verticalHeader().hide()
item = QTableWidgetItem()
item.setText("PIVs")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
item.setText("Confirmations")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
item.setText("TX Hash")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
item.setText("TX Output N")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.rewardsList.addWidget(self.rewardsList.box)
layout.addRow(self.rewardsList)
##--- ROW 3
hBox2 = QHBoxLayout()
self.btn_selectAllRewards = QPushButton("Select All")
self.btn_selectAllRewards.setToolTip("Select all available UTXOs")
hBox2.addWidget(self.btn_selectAllRewards)
self.btn_deselectAllRewards = QPushButton("Deselect all")
self.btn_deselectAllRewards.setToolTip("Deselect current selection")
hBox2.addWidget(self.btn_deselectAllRewards)
hBox2.addWidget(QLabel("Selected rewards"))
self.selectedRewardsLine = QLabel()
self.selectedRewardsLine.setMinimumWidth(200)
self.selectedRewardsLine.setStyleSheet("color: purple")
self.selectedRewardsLine.setToolTip("PIVX to move away")
hBox2.addWidget(self.selectedRewardsLine)
hBox2.addStretch(1)
self.swiftxCheck = QCheckBox()
self.swiftxCheck.setToolTip(
"check for SwiftX instant transaction (flat fee rate of 0.01 PIV)")
hBox2.addWidget(QLabel("Use SwiftX"))
hBox2.addWidget(self.swiftxCheck)
layout.addRow(hBox2)
##--- ROW 4
hBox3 = QHBoxLayout()
self.destinationLine = QLineEdit()
self.destinationLine.setToolTip("PIVX address to transfer rewards to")
hBox3.addWidget(self.destinationLine)
hBox3.addWidget(QLabel("Fee"))
self.feeLine = QDoubleSpinBox()
self.feeLine.setDecimals(8)
self.feeLine.setPrefix("PIV ")
self.feeLine.setToolTip("Insert a small fee amount")
self.feeLine.setFixedWidth(150)
self.feeLine.setSingleStep(0.001)
hBox3.addWidget(self.feeLine)
self.btn_sendRewards = QPushButton("Send")
hBox3.addWidget(self.btn_sendRewards)
layout.addRow(QLabel("Destination Address"), hBox3)
##--- ROW 5
hBox4 = QHBoxLayout()
hBox4.addStretch(1)
self.loadingLine = QLabel(
"<b style='color:red'>Preparing TX.</b> Completed: ")
self.loadingLinePercent = QProgressBar()
self.loadingLinePercent.setMaximumWidth(200)
self.loadingLinePercent.setMaximumHeight(10)
self.loadingLinePercent.setRange(0, 100)
hBox4.addWidget(self.loadingLine)
hBox4.addWidget(self.loadingLinePercent)
self.loadingLine.hide()
self.loadingLinePercent.hide()
layout.addRow(hBox4)
#--- Set Layout
self.rewardsForm.setLayout(layout)
#--- ROW 5
self.btn_Cancel = QPushButton("Clear/Reload")
class TimeInputLine(QFrame):
WIDTH = 396
HEIGHT = 43
FRAME_WIDTH = 1
FRAME_MARGIN = 2
ICON_SIZE = 35
ICON_BUTTON_WIDTH = 60
LABEL_SIZE_X = 174
INPUT_SIZE_X = 100
BUTTON_BLOCK_X = 278
STEP = 0.5
MIN_VALUE = 0.1
MAX_VALUE = 10
DECIMAL_COUNT = 1
def __init__(self, parent):
super().__init__(parent)
self.initUI()
def initUI(self):
self.resize(TimeInputLine.WIDTH + TimeInputLine.FRAME_MARGIN*2, TimeInputLine.HEIGHT + TimeInputLine.FRAME_MARGIN*2)
self.setFrameStyle(QFrame.StyledPanel)
self.setLineWidth(TimeInputLine.FRAME_WIDTH)
component_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
.QDoubleSpinBox {
font-weight: bold;
font-size: 23px;
}
.QLabel {
font-weight: bold;
font-size: 23px;
}
"""
self.label = QLabel("", self)
self.label.resize(TimeInputLine.LABEL_SIZE_X, TimeInputLine.HEIGHT)
self.label.move(TimeInputLine.FRAME_MARGIN, TimeInputLine.FRAME_MARGIN)
self.label.setStyleSheet(component_stylesheet)
self.label.setAlignment(Qt.AlignCenter)
self.label.show()
self.spinbox = QDoubleSpinBox(self)
self.spinbox.setRange(TimeInputLine.MIN_VALUE, TimeInputLine.MAX_VALUE)
self.spinbox.setValue(TimeInputLine.STEP)
self.spinbox.setSingleStep(TimeInputLine.STEP)
self.spinbox.setDecimals(TimeInputLine.DECIMAL_COUNT)
self.spinbox.resize(TimeInputLine.INPUT_SIZE_X, TimeInputLine.HEIGHT)
self.spinbox.move(TimeInputLine.LABEL_SIZE_X + TimeInputLine.FRAME_MARGIN, TimeInputLine.FRAME_MARGIN)
self.spinbox.setStyleSheet(component_stylesheet)
self.spinbox.show()
self.enter = QPushButton("", self)
self.enter.setIcon(assets.enter)
self.enter.setIconSize(QSize(TimeInputLine.ICON_SIZE, TimeInputLine.ICON_SIZE))
self.enter.resize(TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.HEIGHT)
self.enter.move(TimeInputLine.BUTTON_BLOCK_X, TimeInputLine.FRAME_MARGIN)
self.enter.setStyleSheet(component_stylesheet)
self.enter.show()
self.cancel = QPushButton("", self)
self.cancel.setIcon(assets.exit)
self.cancel.setIconSize(QSize(TimeInputLine.ICON_SIZE, TimeInputLine.ICON_SIZE))
self.cancel.resize(TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.HEIGHT)
self.cancel.move(TimeInputLine.BUTTON_BLOCK_X + TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.FRAME_MARGIN)
self.cancel.setStyleSheet(component_stylesheet)
self.cancel.show()
""" listeners which control what happens on accept and on cancel button presses """
def addAcceptListener(self, onAcceptListener):
self.enter.clicked.connect(onAcceptListener)
def addCancelListener(self, onCancelListener):
self.cancel.clicked.connect(onCancelListener)
class TabRewards_gui(QWidget):
def __init__(self, imgDir, *args, **kwargs):
QWidget.__init__(self)
self.imgDir = imgDir
self.initRewardsForm()
mainVertical = QVBoxLayout()
mainVertical.addWidget(self.rewardsForm)
buttonbox = QHBoxLayout()
buttonbox.addStretch(1)
buttonbox.addWidget(self.btn_Cancel)
mainVertical.addLayout(buttonbox)
self.setLayout(mainVertical)
def initRewardsForm(self):
self.rewardsForm = QGroupBox()
self.rewardsForm.setTitle("Transfer UTXOs")
layout = QFormLayout()
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(13)
layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
##--- ROW 1
line1 = QHBoxLayout()
line1.addWidget(QLabel("Account HW"))
self.edt_hwAccount = QSpinBox()
self.edt_hwAccount.setMaximum(9999)
self.edt_hwAccount.setFixedWidth(50)
self.edt_hwAccount.setToolTip(
"account number of the hardware wallet.\nIf unsure put 0")
self.edt_hwAccount.setValue(0)
line1.addWidget(self.edt_hwAccount)
line1.addWidget(QLabel("spath from"))
self.edt_spathFrom = QSpinBox()
self.edt_spathFrom.setMaximum(9999)
self.edt_spathFrom.setFixedWidth(50)
self.edt_spathFrom.setToolTip("starting address n.")
self.edt_spathFrom.setValue(0)
line1.addWidget(self.edt_spathFrom)
line1.addWidget(QLabel("spath to"))
self.edt_spathTo = QSpinBox()
self.edt_spathTo.setMaximum(9999)
self.edt_spathTo.setFixedWidth(50)
self.edt_spathTo.setToolTip("ending address n.")
self.edt_spathTo.setValue(10)
line1.addWidget(self.edt_spathTo)
line1.addWidget(QLabel("internal/external"))
self.edt_internalExternal = QSpinBox()
self.edt_internalExternal.setFixedWidth(50)
self.edt_internalExternal.setToolTip("ending address n.")
self.edt_internalExternal.setValue(0)
self.edt_internalExternal.setMaximum(1)
line1.addWidget(self.edt_internalExternal)
line1.addStretch(1)
self.btn_reload = QPushButton("Scan Ledger device")
self.btn_reload.setToolTip("Reload data from ledger device")
line1.addWidget(self.btn_reload)
layout.addRow(line1)
hBox = QHBoxLayout()
self.addySelect = QComboBox()
self.addySelect.setToolTip("Select Address")
hBox.addWidget(self.addySelect)
layout.addRow(hBox)
## --- ROW 2: UTXOs
self.rewardsList = QVBoxLayout()
self.rewardsList.statusLabel = QLabel(
'<b style="color:red">Reload Rewards</b>')
self.rewardsList.statusLabel.setVisible(True)
self.rewardsList.addWidget(self.rewardsList.statusLabel)
self.rewardsList.box = QTableWidget()
self.rewardsList.box.setMinimumHeight(200)
#self.rewardsList.box.setMaximumHeight(140)
self.rewardsList.box.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.rewardsList.box.setSelectionMode(QAbstractItemView.MultiSelection)
self.rewardsList.box.setSelectionBehavior(QAbstractItemView.SelectRows)
self.rewardsList.box.setShowGrid(True)
self.rewardsList.box.setColumnCount(4)
self.rewardsList.box.setRowCount(0)
self.rewardsList.box.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.rewardsList.box.verticalHeader().hide()
item = QTableWidgetItem()
item.setText("PIVs")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
item.setText("Confirmations")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
item.setText("TX Hash")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
item.setText("TX Output N")
item.setTextAlignment(Qt.AlignCenter)
self.rewardsList.box.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.rewardsList.addWidget(self.rewardsList.box)
layout.addRow(self.rewardsList)
##--- ROW 3
hBox2 = QHBoxLayout()
self.btn_selectAllRewards = QPushButton("Select All")
self.btn_selectAllRewards.setToolTip("Select all available UTXOs")
hBox2.addWidget(self.btn_selectAllRewards)
self.btn_deselectAllRewards = QPushButton("Deselect All")
self.btn_deselectAllRewards.setToolTip("Deselect current selection")
hBox2.addWidget(self.btn_deselectAllRewards)
hBox2.addWidget(QLabel("Selected UTXOs"))
self.selectedRewardsLine = QLabel()
self.selectedRewardsLine.setMinimumWidth(200)
self.selectedRewardsLine.setStyleSheet("color: purple")
self.selectedRewardsLine.setToolTip("PIVX to move away")
hBox2.addWidget(self.selectedRewardsLine)
hBox2.addStretch(1)
self.swiftxCheck = QCheckBox()
self.swiftxCheck.setToolTip(
"check for SwiftX instant transaction (flat fee rate of 0.01 PIV)")
hBox2.addWidget(QLabel("Use SwiftX"))
hBox2.addWidget(self.swiftxCheck)
layout.addRow(hBox2)
##--- ROW 4
hBox3 = QHBoxLayout()
self.destinationLine = QLineEdit()
self.destinationLine.setToolTip("PIVX address to send PIV to")
hBox3.addWidget(self.destinationLine)
hBox3.addWidget(QLabel("Fee"))
self.feeLine = QDoubleSpinBox()
self.feeLine.setDecimals(8)
self.feeLine.setPrefix("PIV ")
self.feeLine.setToolTip("Insert a small fee amount")
self.feeLine.setFixedWidth(150)
self.feeLine.setSingleStep(0.001)
hBox3.addWidget(self.feeLine)
self.btn_sendRewards = QPushButton("Send")
hBox3.addWidget(self.btn_sendRewards)
layout.addRow(QLabel("Destination Address"), hBox3)
hBox4 = QHBoxLayout()
hBox4.addStretch(1)
self.loadingLine = QLabel(
"<b style='color:red'>Preparing TX.</b> Completed: ")
self.loadingLinePercent = QProgressBar()
self.loadingLinePercent.setMaximumWidth(200)
self.loadingLinePercent.setMaximumHeight(10)
self.loadingLinePercent.setRange(0, 100)
hBox4.addWidget(self.loadingLine)
hBox4.addWidget(self.loadingLinePercent)
self.loadingLine.hide()
self.loadingLinePercent.hide()
layout.addRow(hBox4)
#--- Set Layout
self.rewardsForm.setLayout(layout)
#--- ROW 5
self.btn_Cancel = QPushButton("Clear")
def resetStatusLabel(self, message=None):
if message is None:
self.rewardsList.statusLabel.setText(
'<em><b style="color:purple">Checking explorer...</b></em>')
else:
self.rewardsList.statusLabel.setText(message)
self.rewardsList.statusLabel.setVisible(True)
class GcodeUI(object):
def __init__(self, ui, layout):
self.main_ui = ui
self.layout = layout
super(GcodeUI, self).__init__()
self.isOutlineMode = True
self.isLaserMode = True
self.handler = GcodeHandler(self)
self.set_ui()
self.connect_slot()
self.gcode = ''
def set_ui(self):
self._set_up_frame_ui()
self._set_middle_frame_ui()
self._set_down_frame_ui()
def _set_up_frame_ui(self):
self.up_frame = QFrame()
self.up_frame.setMinimumHeight(300)
self.up_frame.setMaximumHeight(500)
self.up_layout = QHBoxLayout(self.up_frame)
up_left_frame = QFrame()
# up_left_frame.setMinimumWidth(self.main_ui.window.geometry().width() / 2)
# up_left_frame.setMaximumWidth(self.geometry().width() / 2)
up_right_frame = QFrame()
# up_right_frame.setMinimumWidth(self.main_ui.window.geometry().width() / 2)
# up_right_frame.setMaximumWidth(self.geometry().width() / 2)
self.up_left_layout = QHBoxLayout(up_left_frame)
self.up_right_layout = QHBoxLayout(up_right_frame)
self.up_layout.addWidget(up_left_frame)
# self.up_layout.addWidget(up_right_frame)
self.layout.addWidget(self.up_frame)
self.label_img = QLabel()
# self.label_img.setMaximumHeight(320)
# self.label_img.setMaximumWidth(480)
# self.label_img.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
# self.label_img.setScaledContents(True)
img = QImage()
if img.load(os.path.join(icon_path, 'tmp.svg')):
self.label_img.setPixmap(QPixmap.fromImage(img))
with open(os.path.join(icon_path, 'tmp.svg'), 'rb') as f:
self.handler.source = f.read()
self.up_left_layout.addWidget(self.label_img)
self.label_img_preview = QLabel()
# self.label_img_preview.setMaximumHeight(320)
# self.label_img_preview.setMaximumWidth(480)
self.label_img_preview.setDisabled(True)
# # self.label_img_preview.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
# # self.label_img_preview.setScaledContents(True)
# data = np.zeros(320 * 240)
# img = QImage(data, 320, 240, QImage.Format_RGB888)
# pixmap = QPixmap.fromImage(img)
# self.label_img_preview.setPixmap(pixmap)
self.up_right_layout.addWidget(self.label_img_preview)
# self.up_frame.hide()
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 _set_down_frame_ui(self):
self.down_frame = QFrame()
self.down_layout = QHBoxLayout(self.down_frame)
self.layout.addWidget(self.down_frame)
self.textEdit = QTextEdit()
self.down_layout.addWidget(self.textEdit)
# self.down_frame.hide()
def select_engrave_mode(self, event):
self.isOutlineMode = event
# print('outline: {}, laser: {}'.format(self.isOutlineMode, self.isLaserMode))
def select_end_type(self, event):
self.isLaserMode = event
self.slider_pen_up.setDisabled(self.isLaserMode)
self.spinbox_pen_up.setDisabled(self.isLaserMode)
self.generate_gcode()
# print('outline: {}, laser: {}'.format(self.isOutlineMode, self.isLaserMode))
def connect_slot(self):
self.checkbox_outline.toggled.connect(self.select_engrave_mode)
self.checkbox_laser.toggled.connect(self.select_end_type)
self.btn_load_img.clicked.connect(self.load_image)
self.slider_x_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_x_home,
scale=.1))
self.spinbox_x_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_x_home,
scale=10))
self.slider_y_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_y_home,
scale=.1))
self.spinbox_y_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_y_home,
scale=10))
self.slider_z_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_z_home,
scale=.1))
self.spinbox_z_home.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_z_home,
scale=10))
self.slider_x_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_x_offset,
scale=.1))
self.spinbox_x_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_x_offset,
scale=10))
self.slider_y_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_y_offset,
scale=.1))
self.spinbox_y_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_y_offset,
scale=10))
self.slider_z_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_z_offset,
scale=.1))
self.spinbox_z_offset.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_z_offset,
scale=10))
self.slider_pen_up.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_pen_up,
scale=.1))
self.spinbox_pen_up.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_pen_up,
scale=10))
self.slider_scale.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_scale,
scale=.1))
self.spinbox_scale.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_scale,
scale=10))
self.slider_resolution.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_resolution,
scale=.1))
self.spinbox_resolution.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_resolution,
scale=10))
self.slider_drawing_feedrate.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_drawing_feedrate,
scale=1))
self.spinbox_drawing_feedrate.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_drawing_feedrate,
scale=1))
self.slider_moving_feedrate.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.spinbox_moving_feedrate,
scale=1))
self.spinbox_moving_feedrate.valueChanged.connect(
functools.partial(self.slider_spinbox_related,
slave=self.slider_moving_feedrate,
scale=1))
self.btn_generate_gcode.clicked.connect(
functools.partial(self.generate_gcode, flag=True))
def slider_spinbox_related(self, value, master=None, slave=None, scale=1):
try:
slave.setValue(value * scale)
except Exception as e:
print(e)
def mouseReleaseEvent(self, event, source=None):
try:
self.generate_gcode()
except Exception as e:
print(e)
source(event)
def focusOutEvent(self, event, source=None):
try:
self.generate_gcode()
except Exception as e:
print(e)
source(event)
def generate_gcode(self, flag=False):
if self.handler.template is None and flag:
self.handler.svg_to_gcode()
if self.handler.template:
pen_up = self.spinbox_pen_up.value() if not self.isLaserMode else 0
config = {
'x_home': self.spinbox_x_home.value(),
'y_home': self.spinbox_y_home.value(),
'z_home': self.spinbox_z_home.value(),
'z_offset': self.spinbox_z_offset.value(),
'pen_up': pen_up,
'z_offset_pen_up': self.spinbox_z_offset.value() + pen_up,
'moving_feedrate': self.spinbox_moving_feedrate.value(),
'drawing_feedrate': self.spinbox_drawing_feedrate.value(),
}
self.gcode = self.handler.template.format(**config)
self.change_gcode()
# self.textEdit.setText(self.gcode)
def change_gcode(self):
if self.gcode:
x_offset = self.spinbox_x_offset.value()
y_offset = self.spinbox_y_offset.value()
z_offset = self.spinbox_z_offset.value()
moving_feedrate = self.spinbox_moving_feedrate.value()
drawing_feedrate = self.spinbox_drawing_feedrate.value()
scale = self.spinbox_scale.value()
lines = self.gcode.split('\n')
for i, line in enumerate(lines):
List = line.strip().split(' ')
line = ''
for l in List:
if l.startswith('F'):
if line.startswith(('G01', 'G1')):
l = 'F{}'.format(drawing_feedrate)
elif line.startswith(('G00', 'G0')):
l = 'F{}'.format(moving_feedrate)
elif l.startswith('X'):
x = float(l[1:]) * scale + x_offset
l = 'X{0:.2f}'.format(x)
elif l.startswith('Y'):
y = float(l[1:]) * scale + y_offset
l = 'Y{0:.2f}'.format(y)
# elif l.startswith('Z'):
# z = float(l[1:]) + z_offset
# l = 'Z{0:.2f}'.format(z)
line += l + ' '
line = line.strip()
lines[i] = line
self.calc_gcode(lines)
gcode = '\n'.join(lines)
self.textEdit.setText(gcode)
def calc_gcode(self, lines):
x_list = []
y_list = []
for i, line in enumerate(lines):
if line.startswith(tuple(['G0', 'G1', 'G00', 'G01'])):
List = line.strip().split(' ')
for l in List:
if l.startswith('X'):
x = float(l[1:])
x_list.append(x)
elif l.startswith('Y'):
y = float(l[1:])
y_list.append(y)
if len(x_list) > 0:
x_min = np.min(x_list)
x_max = np.max(x_list)
self.label_x_min.setText('X(min): ' + str(x_min))
self.label_x_max.setText('X(max): ' + str(x_max))
# print('x_min: {}, x_max: {}, x_distance: {}'.format(x_min, x_max, x_max - x_min))
if len(y_list) > 0:
y_min = np.min(y_list)
y_max = np.max(y_list)
self.label_y_min.setText('Y(min): ' + str(y_min))
self.label_y_max.setText('Y(max): ' + str(y_max))
# print('y_min: {}, y_max: {}, y_distance: {}'.format(y_min, y_max, y_max - y_min))
def load_image(self):
fname = QFileDialog.getOpenFileName(self.main_ui.window, 'Open file',
'', '*.svg')
if fname and fname[0]:
img = QImage()
if img.load(fname[0]):
self.label_img.setPixmap(QPixmap.fromImage(img))
with open(fname[0], 'rb') as f:
self.handler.source = f.read()
self.handler.template = None
self.gcode = None
self.up_frame.show()
def createPcCalibrationControls():
gb = QGroupBox("PC Calibration")
#-------------------------------------------
layout = QHBoxLayout()
label = QLabel("Calibration offset for 180:")
global offAt180_sb
offAt180_sb = QDoubleSpinBox()
offAt180_sb.setRange(-4.0, 0.0)
offAt180_sb.setSingleStep(0.5)
offAt180_sb.setValue(-3.5)
offAt180_sb.setMaximumWidth(60)
layout.addWidget(label)
layout.addWidget(offAt180_sb)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------
layout = QHBoxLayout()
btn2p5 = QPushButton("2.5")
btn2p5.clicked.connect(lambda: offAt180_sb.setValue(-2.5))
btn3 = QPushButton("3.0")
btn3.clicked.connect(lambda: offAt180_sb.setValue(-3.0))
btn3p5 = QPushButton("3.5")
btn3p5.clicked.connect(lambda: offAt180_sb.setValue(-3.5))
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(btn2p5)
layout.addWidget(btn3)
layout.addWidget(btn3p5)
middle = QWidget()
middle.setLayout(layout)
#-------------------------------------------
layout = QHBoxLayout()
label = QLabel("Running Angle offset:")
global runningAngleOffset_sb
runningAngleOffset_sb = QSpinBox()
runningAngleOffset_sb.setToolTip(
"offset in degrees to add to the angle reported by arduino")
runningAngleOffset_sb.setRange(0, 5)
runningAngleOffset_sb.setValue(2)
runningAngleOffset_sb.setMaximumWidth(60)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(label)
layout.addWidget(runningAngleOffset_sb)
lower = QWidget()
lower.setLayout(layout)
#-------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addWidget(middle)
vbox.addWidget(lower)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
gb.setLayout(vbox)
return gb
class SliderWidget(QDialog):
'''
class SliderWidget
'''
valueChanged = QtCore.pyqtSignal(float)
def __init__(self, title, parent = None):
super(SliderWidget, self).__init__(parent, Qt.FramelessWindowHint)
self._mousePressed = False
self._orgPos = QPoint(0, 0)
self.setObjectName('SliderWidget')
self.resize(500, 150)
#
self.stylize()
# main layout
labelTitle = QLabel(title, self)
buttonClose = JCloseButton(self)
buttonClose.setObjectName('buttonClose')
buttonClose.setToolTip('关闭')
horiLayoutTitle = QHBoxLayout()
horiLayoutTitle.setContentsMargins(6, 0, 6, 6)
horiLayoutTitle.addWidget(labelTitle, 0, Qt.AlignTop)
horiLayoutTitle.addStretch()
horiLayoutTitle.addWidget(buttonClose, 0, Qt.AlignTop)
self.doubleSpinBox = QDoubleSpinBox(self)
self.doubleSpinBox.setObjectName('doubleSpinBox')
self.doubleSpinBox.setMinimumWidth(200)
self.doubleSpinBox.setRange(0, 6000)
self.doubleSpinBox.setDecimals(2)
self.doubleSpinBox.setSingleStep(0.01)
self.slider = QSlider(Qt.Horizontal, self)
self.slider.setObjectName('slider')
self.slider.setRange(self.doubleSpinBox.minimum(),
self.doubleSpinBox.maximum())
vertLayoutMain = QVBoxLayout(self)
vertLayoutMain.addLayout(horiLayoutTitle)
vertLayoutMain.addWidget(self.doubleSpinBox, 0, Qt.AlignHCenter)
vertLayoutMain.addSpacing(5)
vertLayoutMain.addWidget(self.slider)
self.slider.rangeChanged.connect(self.doubleSpinBox.setRange)
self.doubleSpinBox.valueChanged.connect(self.doubleSpinBoxValueChanged)
self.slider.valueChanged.connect(self.setValue)
buttonClose.clicked.connect(self.close)
def setRange(self, minValue, maxValue):
self.slider.setRange(minValue, maxValue)
def setDecimals(self, prec):
self.doubleSpinBox.setDecimals(prec)
def setSingleStep(self, value):
self.doubleSpinBox.setSingleStep(value)
def setPrefix(self, prefix):
self.doubleSpinBox.setPrefix(prefix)
def setSuffix(self, suffix):
self.doubleSpinBox.setSuffix(suffix)
def doubleSpinBoxValueChanged(self, value):
self.slider.setValue(value)
self.valueChanged.emit(value)
@QtCore.pyqtSlot(float)
def setValue(self, value):
self.doubleSpinBox.setValue(value)
@QtCore.pyqtSlot()
def stylize(self):
styles.stylize(self)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self._mousePressed = True
self._orgPos = event.pos()
self.setCursor(Qt.ClosedHandCursor)
def mouseMoveEvent(self, event):
if self._mousePressed:
curPos = event.pos()
curGeom = self.geometry()
self.move(curGeom.topLeft() + curPos - self._orgPos)
def mouseReleaseEvent(self, event):
self._mousePressed = False
self.setCursor(Qt.ArrowCursor)
