class MainForm(QDialog):
def __init__(self, parent=None):
# Create our main`layout for picking duration and such
super(MainForm, self).__init__(parent)
self.setWindowTitle("SelfRestraint")
# Create widgets such as buttons and slider
self.editButton = QPushButton("Edit Blocklist")
self.startButton = QPushButton("Start")
self.timeSlider = QSlider(Qt.Horizontal)
self.timeLabel = QLabel('Disabled')
# Disable start button
self.startButton.setEnabled(False)
# Mess with the slider
self.timeSlider.setTickPosition(QSlider.TicksBelow)
self.timeSlider.setTickInterval(1)
# Edit button widths
self.startButton.setFixedWidth(90)
self.editButton.setFixedWidth(120)
self.setFixedSize(600,150)
# Create another layout to hold bottom contents
bottomRow = QHBoxLayout()
layout = QVBoxLayout()
# Add to the layout
layout.addWidget(self.startButton,0,Qt.AlignHCenter)
layout.addWidget(self.timeSlider)
bottomRow.addWidget(self.timeLabel)
bottomRow.addWidget(self.editButton,0,Qt.AlignRight)
layout.addLayout(bottomRow)
# Set layout
self.setLayout(layout)
# Link functions to button and slider
self.startButton.clicked.connect(backend.startBlock)
self.timeSlider.valueChanged.connect(self.change)
self.editButton.clicked.connect(self.openList)
def openList(self):
"""docstring for openList"""
list.show()
# Displays the block time on the label
def change(self):
"""docstring for change"""
if self.timeSlider.value() == 0:
self.timeLabel.setText("Disabled")
self.startButton.setEnabled(False)
return
self.startButton.setEnabled(True)
loc = self.timeSlider.value()* 15
if ((loc-loc%60)/60) == 1:
hours = str((loc-loc%60)/60)+" hour, "
elif ((loc-loc%60)/60) == 0:
hours = ""
else:
hours = str((loc-loc%60)/60)+" hours, "
self.timeLabel.setText(hours+str(loc%60) +" minutes")
def getSlider(self, parent):
sld = QSlider(parent)
sld.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
sld.setMinimum(0)
sld.setMaximum(99)
sld.setPageStep(10)
sld.setPageStep(10)
sld.setMinimumHeight(50)
sld.setTickInterval(25)
sld.setTickPosition(QSlider.TicksBothSides)
return sld
def getSlider(self, parent):
sld = QSlider(parent)
sld.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
sld.setMinimum(0)
sld.setMaximum(99)
sld.setPageStep(10)
sld.setPageStep(10)
sld.setMinimumHeight(50)
sld.setTickInterval(25)
sld.setTickPosition(QSlider.TicksBothSides)
return sld
class QCustomSlider(QWidget):
def __init__(self, sliderOrientation=None):
super(QCustomSlider, self).__init__()
self._slider = QSlider(sliderOrientation)
self.setLayout(QVBoxLayout())
self._labelTicksWidget = QWidget(self)
self._labelTicksWidget.setLayout(QHBoxLayout())
self._labelTicksWidget.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self._slider)
self.layout().addWidget(self._labelTicksWidget)
def setTickLabels(self, listWithLabels):
lengthOfList = len(listWithLabels)
for index, label in enumerate(listWithLabels):
label = QLabel(str(label))
label.setContentsMargins(0, 0, 0, 0)
if index > lengthOfList/3:
label.setAlignment(QtCore.Qt.AlignCenter)
if index > 2*lengthOfList/3:
label.setAlignment(QtCore.Qt.AlignRight)
self._labelTicksWidget.layout().addWidget(label)
def setRange(self, mini, maxi):
self._slider.setRange(mini, maxi)
def setPageStep(self, value):
self._slider.setPageStep(value)
def setTickInterval(self, value):
self._slider.setTickInterval(value)
def setTickPosition(self, position):
self._slider.setTickPosition(position)
def setValue(self, value):
self._slider.setValue(value)
def onValueChangedCall(self, function):
self._slider.valueChanged.connect(function)
class MainWin(QMainWindow):
def __init__(self, mx, spurs, fef, parent=None, plot_lib='mpl'):
QMainWindow.__init__(self, parent)
self.mx = mx
self.spurset = spurs
self.fef = fef
if plot_lib == 'qwt':
from chart.qwtchart import qwtchart as chart
elif plot_lib == 'mpl':
from chart.mplchart import mplchart as chart
elif plot_lib == 'pg':
from chart.pyqtgraphchart import pyqtgraphchart as chart
else:
raise NotImplementedError
self.chart = chart(self.spurset, self.fef, self)
self.create_menu_bar()
self.create_main_frame()
self.hookup()
def hookup(self):
# connect all the objects that are supposed to be watching each other
# for changes and updates.
self.mx.register(self.chart.draw_spurs)
self.spurset.register(self.chart.draw_spurs)
self.chart.picker_watch(self.fef)
self.fef.register(self.chart.draw_fef)
self.chart.draw_spurs(self.spurset)
self.chart.draw_fef(self.fef)
def IF_slide(self, i):
""" callback method for the IF selection slider"""
self.IFtextbox.setText(str(i))
self.mx.IF = i
def about(self):
msg = '''
A frequency-planing tool based on the method of spur distances.
(A reference to the article will go here)
For more info, view the README included with this program.
Patrick Yeon, 2012'''
QMessageBox.about(self, 'Spur Distance Chart', msg.strip())
def mxtypecb(self, i):
""" callback method for mixer configuration selection combobox"""
self.mx.m, self.mx.n = [(-1, 1), (1, -1), (1, 1)][i]
# trigger anything watching the mixer
self.mx.update_watchers()
def create_main_frame(self):
self.main_frame = QWidget()
# Looking at the main frame as two columns. On the left there is the
# chart and the IF control. In the right column we'll have range
# settings, mixer settings, and maybe other stuff that comes up?
self.IFtextbox = QLineEdit()
self.IFtextbox.setMinimumWidth(6)
self.IFtextbox.setText(str(self.spurset.mixer.IF))
# TODO link up the textbox so that it can also be input
self.IFslider = QSlider(Qt.Horizontal)
# TODO I'd really like some form of slider that doesn't actually limit
# the user. Also, if IFtextbox could modify the IF, that'd be nice.
self.IFslider.setRange(int(self.mx.IF * 0.1), (self.mx.IF * 5))
self.IFslider.setValue(self.mx.IF)
self.IFslider.setTracking(True)
self.IFslider.setTickPosition(QSlider.TicksAbove)
step = max(1, int(0.01 * self.mx.IF))
self.IFslider.setSingleStep(step)
self.IFslider.setPageStep(step * 10)
self.IFcid = self.connect(self.IFslider, SIGNAL('valueChanged(int)'),
self.IF_slide)
IFbar = QHBoxLayout()
IFbar.addWidget(QLabel('IF'))
IFbar.addWidget(self.IFtextbox)
IFbar.addWidget(self.IFslider)
IFbar.addStretch()
leftcol = QVBoxLayout()
leftcol.addWidget(self.chart.plot)
leftcol.addLayout(IFbar)
# left column done. Now the right-hand side
rangebox = QVBoxLayout()
for (prop, name, f) in [(spurset.RFmin, 'RFmin', self.spurset.RFmin),
(spurset.RFmax, 'RFmax', self.spurset.RFmax),
(spurset.dspan, 'dspan', self.spurset.dspan)]:
rangebox.addLayout(Fbar(self.spurset, prop, name, f, 0, 10000))
autocb = QCheckBox('Auto')
# Disable it, won't be implemented for release
# but leave it there, to nag me into doing it.
autocb.setDisabled(True)
rangebox.addWidget(autocb)
# a line to report the front-end filter's limits
fefstat = QHBoxLayout()
fefstat.addWidget(QLabel('Filter Range: '))
fefrange = QLabel('%d - %d' % (self.fef.start, self.fef.stop))
# TODO not sure about the lambda here. Feels like if I give it time,
# I'll sort out a sensible overall connection scheme.
self.fef.register(lambda o: fefrange.setText('%d - %d' % (
self.fef.start, self.fef.stop)))
fefstat.addWidget(fefrange)
# mixer high/low-side injection picker
mxbar = QHBoxLayout()
mxbar.addWidget(QLabel('IF = '))
mxtype = QComboBox()
mxtype.addItem('LO - RF')
mxtype.addItem('RF - LO')
mxtype.addItem('RF + LO')
# TODO this is ugly
mxtype.setCurrentIndex([(-1, 1), (1, -1), (1, 1)].index(
(self.mx.m, self.mx.n)))
self.mxtypecid = self.connect(mxtype,
SIGNAL('currentIndexChanged(int)'),
self.mxtypecb)
mxbar.addWidget(mxtype)
# alright, the actual column proper in the layout
vbar = QVBoxLayout()
vbar.addLayout(rangebox)
vbar.addLayout(fefstat)
vbar.addLayout(mxbar)
legend = self.chart.legend()
vbar.addWidget(legend)
# need to let the legend stretch so that everything fits in it
vbar.setStretchFactor(legend, 1)
vbar.addStretch()
hbox = QHBoxLayout()
hbox.addLayout(leftcol)
hbox.addLayout(vbar)
# make sure the legend doesn't stretch so far horizontally that the
# chart suffers considerable loss of space.
hbox.setStretchFactor(leftcol, 5)
hbox.setStretchFactor(vbar, 1)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
def create_menu_bar(self):
filemenu = self.menuBar().addMenu('&File')
close = QAction('&Quit', self)
close.setShortcut('Ctrl+W')
self.connect(close, SIGNAL('triggered()'), self.close)
filemenu.addAction(close)
helpmenu = self.menuBar().addMenu('&Help')
about = QAction('&About', self)
about.setShortcut('F1')
self.connect(about, SIGNAL('triggered()'), self.about)
helpmenu.addAction(about)
class QtSlider(QtControl, ProxySlider):
""" A Qt implementation of an Enaml ProxySlider.
"""
#: A reference to the widget created by the proxy.
widget = Typed(QSlider)
#: Cyclic notification guard flags.
_guard = Int(0)
#--------------------------------------------------------------------------
# Initialization API
#--------------------------------------------------------------------------
def create_widget(self):
""" Create the underlying QSlider widget.
"""
self.widget = QSlider(self.parent_widget())
def init_widget(self):
""" Initialize the underlying widget.
"""
super(QtSlider, self).init_widget()
d = self.declaration
self.set_minimum(d.minimum)
self.set_maximum(d.maximum)
self.set_value(d.value)
self.set_orientation(d.orientation)
self.set_page_step(d.page_step)
self.set_single_step(d.single_step)
self.set_tick_interval(d.tick_interval)
self.set_tick_position(d.tick_position)
self.set_tracking(d.tracking)
self.widget.valueChanged.connect(self.on_value_changed)
#--------------------------------------------------------------------------
# Signal Handlers
#--------------------------------------------------------------------------
def on_value_changed(self):
""" Send the 'value_changed' action to the Enaml widget when the
slider value has changed.
"""
if not self._guard & VALUE_FLAG:
self._guard |= VALUE_FLAG
try:
self.declaration.value = self.widget.value()
finally:
self._guard &= ~VALUE_FLAG
#--------------------------------------------------------------------------
# ProxySlider API
#--------------------------------------------------------------------------
def set_maximum(self, maximum):
""" Set the maximum value of the underlying widget.
"""
self.widget.setMaximum(maximum)
def set_minimum(self, minimum):
""" Set the minimum value of the underlying widget.
"""
self.widget.setMinimum(minimum)
def set_value(self, value):
""" Set the value of the underlying widget.
"""
if not self._guard & VALUE_FLAG:
self._guard |= VALUE_FLAG
try:
self.widget.setValue(value)
finally:
self._guard &= ~VALUE_FLAG
def set_page_step(self, page_step):
""" Set the page step of the underlying widget.
"""
self.widget.setPageStep(page_step)
def set_single_step(self, single_step):
""" Set the single step of the underlying widget.
"""
self.widget.setSingleStep(single_step)
def set_tick_interval(self, interval):
""" Set the tick interval of the underlying widget.
"""
self.widget.setTickInterval(interval)
def set_tick_position(self, tick_position):
""" Set the tick position of the underlying widget.
"""
self.widget.setTickPosition(TICK_POSITION[tick_position])
def set_orientation(self, orientation):
""" Set the orientation of the underlying widget.
"""
self.widget.setOrientation(ORIENTATION[orientation])
def set_tracking(self, tracking):
""" Set the tracking of the underlying widget.
"""
self.widget.setTracking(tracking)
class options(QWidget):
def __init__(self, parent):
QWidget.__init__(self)
self.init(parent)
self.initShape()
def init(self, parent):
self.heditor = parent
def initShape(self):
self.vbox = QVBoxLayout()
self.optab = QTabWidget()
self.fill = QWidget()
self.createHexOptions()
# self.createPageOptions()
self.createPixelOptions()
self.vbox.addWidget(self.optab)
self.createButtons()
self.vbox.addWidget(self.fill)
self.setLayout(self.vbox)
def createPageOptions(self):
self.pagegrid = QGridLayout()
self.pagegroup = QWidget()
pagelabel = QLabel("Page size : ")
self.sizeEdit = QFFSpinBox(self)
self.sizeEdit.setMaximum(self.heditor.filesize)
self.sizeEdit.setValue(self.heditor.pageSize)
# psize = QString("%.2d" % self.heditor.pageSize)
# self.sizeEdit.insert(psize)
headerlabel = QLabel("Header size : ")
self.headEdit = QFFSpinBox(self)
self.headEdit.setMaximum(self.heditor.filesize)
self.headEdit.setValue(self.heditor.pageHead)
# phead = QString("%.2d" % self.heditor.pageHead)
# self.headEdit.insert(phead)
sparelabel = QLabel("Spare size : ")
self.spareEdit = QFFSpinBox(self)
self.spareEdit.setMaximum(self.heditor.filesize)
self.spareEdit.setValue(self.heditor.pageSpare)
# pspare = QString("%.2d" % self.heditor.pageSpare)
# self.spareEdit.insert(pspare)
ppb = QLabel("Pages per block:")
self.pagesperblock = QComboBox()
self.pagesperblock.addItem("8")
self.pagesperblock.addItem("16")
self.pagesperblock.addItem("32")
self.pagesperblock.addItem("64")
self.pagesperblock.addItem("128")
self.pagesperblock.addItem("256")
self.pagesperblock.addItem("512")
self.pagesperblock.setCurrentIndex(2)
lview = QLabel("Left indication: ")
self.indic = QComboBox()
self.indic.addItem("Offset")
self.indic.addItem("Block")
# self.pagesperlineEdit = QLineEdit()
# ppl = QString("%.2d" % self.heditor.pagesPerBlock)
# self.pagesperlineEdit.insert(ppl)
self.pagegrid.addWidget(pagelabel, 0, 0)
self.pagegrid.addWidget(self.sizeEdit, 0, 1)
self.pagegrid.addWidget(headerlabel, 1, 0)
self.pagegrid.addWidget(self.headEdit, 1, 1)
self.pagegrid.addWidget(sparelabel, 2, 0)
self.pagegrid.addWidget(self.spareEdit, 2, 1)
self.pagegrid.addWidget(ppb, 3, 0)
self.pagegrid.addWidget(self.pagesperblock, 3, 1)
self.pagegrid.addWidget(lview, 4, 0)
self.pagegrid.addWidget(self.indic, 4, 1)
self.pagegrid.addWidget(self.fill, 5, 0)
self.pagegrid.setRowStretch(5, 1)
# self.pagegrid.addWidget(self.fill, 6, 0)
# self.pagegrid.addWidget(pagesperline, 6, 0)
# self.pagegrid.addWidget(self.pagesperlineEdit, 7, 0)
self.pagegroup.setLayout(self.pagegrid)
self.vvbox.addWidget(self.pagegroup)
# self.optab.insertTab(1, self.pagegroup, "Pages" )
# self.vbox.addWidget(self.pagegroup)
def createHexOptions(self):
self.vvbox = QVBoxLayout()
self.vcontainer = QWidget()
self.hexgroup = QWidget()
self.hexgrid = QGridLayout()
groupebylabel = QLabel("Groupe by:")
self.groupeby = QComboBox()
self.groupeby.addItem("1")
self.groupeby.addItem("2")
self.groupeby.addItem("4")
offsetlabel = QLabel("Offset as")
self.offsetas = QComboBox()
self.offsetas.addItem("Hexadecimal")
self.offsetas.addItem("Decimal")
# self.hexgrid.addWidget(groupebylabel, 0, 0)
# self.hexgrid.addWidget(self.groupeby, 1, 0)
self.hexgrid.addWidget(offsetlabel, 0, 0)
self.hexgrid.addWidget(self.offsetas, 0, 1)
# self.hexgrid.addWidget(self.fill, 2, 0)
# self.hexgrid.setRowStretch(2, 1)
self.hexgroup.setLayout(self.hexgrid)
self.vvbox.addWidget(self.hexgroup)
self.createPageOptions()
self.vcontainer.setLayout(self.vvbox)
self.optab.insertTab(0, self.vcontainer, "General")
# self.vbox.addWidget(self.hexgroup)
#Offset as decimal / hexadecimal
def createPixelOptions(self):
self.pixgroup = QWidget()
self.pixgrid = QGridLayout()
formatlabel = QLabel("Format :")
self.format = QComboBox()
self.format.addItem("RGB")
self.format.addItem("Alpha RGB")
self.format.addItem("Indexed 8bit")
self.format.addItem("Mono")
self.connect(self.format, SIGNAL("currentIndexChanged(const QString)"),
self.formatChanged)
colorlabel = QLabel("Indexed Color :")
self.icolor = QComboBox()
self.icolor.addItem("Green")
self.icolor.addItem("Red")
self.icolor.addItem("Blue")
self.icolor.addItem("Ascii")
self.icolor.addItem("256")
self.icolor.setEnabled(False)
slidelabel = QLabel("Resolution : ")
self.sliderspin = QSpinBox(self)
self.sliderspin.setMinimum(64)
self.sliderspin.setMaximum(1024)
self.sliderspin.setValue(self.heditor.wpixel.view.w)
self.connect(self.sliderspin, SIGNAL("valueChanged(int)"),
self.slidermoved)
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(64)
self.slider.setMaximum(1024)
self.slider.setValue(self.heditor.wpixel.view.w)
self.slider.setSingleStep(1)
self.zoomlabel = QLabel("Scale factor : 1")
self.zoom = QSlider(Qt.Horizontal)
self.zoom.setMinimum(1)
self.zoom.setMaximum(5)
self.zoom.setValue(1)
self.zoom.setSingleStep(1)
self.zoom.setTickInterval(1)
self.zoom.setTickPosition(QSlider.TicksBelow)
self.connect(self.slider, SIGNAL("sliderMoved(int)"), self.slidermoved)
self.connect(self.zoom, SIGNAL("sliderMoved(int)"), self.scale)
self.pixgrid.addWidget(formatlabel, 0, 0)
self.pixgrid.addWidget(self.format, 0, 1)
self.pixgrid.addWidget(colorlabel, 1, 0)
self.pixgrid.addWidget(self.icolor, 1, 1)
self.pixgrid.addWidget(slidelabel, 2, 0)
self.pixgrid.addWidget(self.sliderspin, 2, 1, Qt.AlignLeft)
self.pixgrid.addWidget(self.slider, 3, 0)
self.pixgrid.addWidget(self.zoomlabel, 4, 0, Qt.AlignLeft)
self.pixgrid.addWidget(self.zoom, 5, 0)
self.pixgrid.addWidget(self.fill, 6, 0)
self.pixgrid.setRowStretch(6, 1)
self.pixgroup.setLayout(self.pixgrid)
self.optab.insertTab(1, self.pixgroup, "Pixel")
def setSliderLabel(self, value):
cvalue = QString()
cvalue = "%2.d" % value
self.sliderlabel.setText(cvalue)
def setZoomLabel(self, value):
zvalue = QString("Scale factor : ")
zvalue += "%2.d" % value
self.zoomlabel.setText(zvalue)
def createButtons(self):
self.applyB = QPushButton("Apply")
self.connect(self.applyB, SIGNAL('clicked()'), self.apply)
self.vbox.addWidget(self.applyB)
def checkValue(self, value):
try:
n = int(value)
return n
except ValueError:
return -1
def apply(self):
#PAGE CHECK
pagesize = self.sizeEdit.value()
headsize = self.headEdit.value()
sparesize = self.spareEdit.value()
pagesperblock = self.checkValue(self.pagesperblock.currentText())
if (pagesize < 0) or (headsize < 0) or (sparesize <
0) or (pagesperblock < 0):
print "Wrong values"
else:
offas = self.offsetas.currentText()
if offas == "Decimal":
self.heditor.decimalview = True
elif offas == "Hexadecimal":
self.heditor.decimalview = False
#Hexview refresh
self.heditor.readOffset(self.heditor.currentOffset)
#Pageview refresh
if self.indic.currentText() == "Offset":
self.heditor.pageOffView = True
else:
self.heditor.pageOffView = False
self.heditor.refreshPageValues(headsize, pagesize, sparesize,
pagesperblock)
if self.heditor.wpage.scroll:
self.heditor.wpage.scroll.refreshValues(
self.heditor.pagesPerBlock, self.heditor.pageSize)
self.heditor.wpage.view.refreshAllContent()
#PageView scrollbar refres
#Pixel View refresh
format = self.format.currentText()
if format == "Indexed 8bit":
self.heditor.wpixel.view.format = 0
elif format == "Mono":
self.heditor.wpixel.view.format = 1
elif format == "RGB":
self.heditor.wpixel.view.format = 2
elif format == "Alpha RGB":
self.heditor.wpixel.view.format = 3
if self.heditor.wpixel.scroll:
self.heditor.wpixel.scroll.refreshValues()
#Color
icolor = self.icolor.currentText()
if icolor == "Red":
self.heditor.wpixel.view.icolor = 0
elif icolor == "Green":
self.heditor.wpixel.view.icolor = 1
elif icolor == "Blue":
self.heditor.wpixel.view.icolor = 2
elif icolor == "Ascii":
self.heditor.wpixel.view.icolor = 3
elif icolor == "256":
self.heditor.wpixel.view.icolor = 4
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.read_image(pixoffset)
def slidermoved(self, value):
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.w = value
self.sliderspin.setValue(value)
# self.setSliderLabel(value)
self.heditor.wpixel.view.read_image(pixoffset)
if self.heditor.wpixel.scroll:
self.heditor.wpixel.scroll.refreshValues()
# print value
def scale(self, value):
self.setZoomLabel(value)
self.heditor.wpixel.view.scale = value
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.read_image(pixoffset)
def formatChanged(self, format):
if format == "Indexed 8bit":
self.icolor.setEnabled(True)
else:
self.icolor.setEnabled(False)
def keyPressEvent(self, kEvent):
key = kEvent.key()
if key == Qt.Key_Return or key == Qt.Key_Enter:
self.apply()
class LogDialog(QDialogWithDpi):
"""LogDialog for the Freeseer project.
It is the dialog window for the log.
There is an instance for every FreeseerApp.
It has a LogHandler which calls LogDialog's
message() method when a new log message is received.
The call to message() causes a call to add_entry()
which adds the information to a new row in the table.
"""
def __init__(self, parent=None):
super(LogDialog, self).__init__(parent)
self.resize(800, 500)
self.app = QApplication.instance()
icon = QIcon()
icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal,
QIcon.Off)
self.setWindowIcon(icon)
layout = QVBoxLayout()
self.setLayout(layout)
self.level = 0
self.handler = LogHandler()
self.table_model = QStandardItemModel(0, 5)
header_names = ["Date", "Level", "Module", "Message", "LevelNo"]
date_column = header_names.index("Date")
level_column = header_names.index("Level")
module_column = header_names.index("Module")
self.level_num_column = header_names.index("LevelNo")
self.table_model.setHorizontalHeaderLabels(header_names)
self.table_view = QTableView()
self.table_view.setModel(self.table_model)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.setColumnWidth(date_column,
self.set_width_with_dpi(125))
self.table_view.setColumnWidth(level_column,
self.set_width_with_dpi(60))
self.table_view.setColumnWidth(module_column,
self.set_width_with_dpi(250))
self.table_view.setColumnHidden(self.level_num_column, True)
self.table_view.setShowGrid(False)
self.table_view.horizontalHeader().setClickable(False)
self.table_view.verticalHeader().hide()
self.table_view.setStyleSheet("""Qtable_view::item {
border-bottom: 1px solid lightgrey;
selection-background-color: white;
selection-color: black;
}""")
top_panel = QHBoxLayout()
self.log_levels = ["Debug", "Info", "Warning", "Error"]
self.level_colors = ["#3E4C85", "#269629", "#B0AB21", "#B32020"]
self.levels_label = QLabel("Filter Level: ")
self.levels_label.setStyleSheet("QLabel { font-weight: bold }")
self.current_level_label = QLabel(self.log_levels[0])
self.current_level_label.setStyleSheet("QLabel {{ color: {} }}".format(
self.level_colors[0]))
self.clear_button = QPushButton("Clear Log")
self.levels_slider = QSlider(Qt.Horizontal)
self.levels_slider.setStyleSheet("""
QSlider::handle:horizontal {
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
stop:0 #FFFFFF, stop:1 #E3E3E3);
border: 1px solid #707070;
width: 10px;
margin-top: -4px;
margin-bottom: -4px;
border-radius: 4px;
}
QSlider::handle:horizontal:hover {
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
stop:0 #DEDEDE, stop:1 #C9C9C9);
border: 1px solid #4F4F4F;
border-radius: 4px;
}
QSlider::sub-page:horizontal {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #BFBFBF, stop: 1 #9E9E9E);
background: qlineargradient(x1: 0, y1: 0.2, x2: 1, y2: 1,
stop: 0 #9E9E9E, stop: 1 #858585);
border: 1px solid #777;
height: 10px;
border-radius: 4px;
}
QSlider::add-page:horizontal {
background: #fff;
border: 1px solid #707070;
height: 10px;
border-radius: 4px;
}""")
self.levels_slider.setRange(0, len(self.log_levels) - 1)
self.levels_slider.setTickPosition(QSlider.TicksBelow)
self.levels_slider.setTickInterval(1)
top_panel.addSpacerItem(self.qspacer_item_with_dpi(10, 0))
top_panel.addWidget(self.levels_label, 3)
top_panel.addWidget(self.current_level_label, 2)
top_panel.addWidget(self.levels_slider, 8)
top_panel.addSpacerItem(self.qspacer_item_with_dpi(25, 0))
top_panel.addWidget(self.clear_button, 10)
layout.addLayout(top_panel)
layout.addWidget(self.table_view)
self.connect(self.clear_button, SIGNAL('clicked()'),
functools.partial(self.table_model.setRowCount, 0))
self.connect(self.levels_slider, SIGNAL('valueChanged(int)'),
self.slider_set_level)
self.setWindowTitle("Log")
self.handler.add_listener(self)
def __del__(self):
self.handler.remove_listener(self)
def retranslate(self):
self.setWindowTitle(self.app.translate("LogDialog", "Log"))
self.clear_button.setText(self.app.translate("LogDialog", "Clear Log"))
self.levels_label.setText("{}: ".format(
self.app.translate("LogDialog", "Filter Level")))
def message(self, message):
"""Passes the log fields to add_entry()
It is called by LogHandler when a log message is received"""
self.add_entry(message["time"], message["level"],
message["full_module_name"], message["message"],
str(message["levelno"]))
def add_entry(self, date, level, module, message, levelno):
"""Adds the given fields to a new row in the log table
It is called by message() when a log message is received"""
items = [
QStandardItem(date),
QStandardItem(level),
QStandardItem(module),
QStandardItem(message),
QStandardItem(levelno)
]
for item in items:
item.setEditable(False)
self.table_model.appendRow(items)
def slider_set_level(self, level):
self.current_level_label.setText(self.log_levels[level])
self.current_level_label.setStyleSheet("QLabel {{ color: {} }}".format(
self.level_colors[level]))
self.set_level(level + 1)
def set_level(self, level):
"""Sets the current level of the LogDialog.
Level is based on the selection made in the levels_combo_box.
It hides all messages with a lower level."""
self.level = level * 10
for i in range(self.table_model.rowCount()):
if int(str(self.table_model.item(
i, self.level_num_column).text())) < self.level:
self.table_view.setRowHidden(i, True)
else:
self.table_view.setRowHidden(i, False)
class options(QWidget):
def __init__(self, parent):
QWidget.__init__(self)
self.init(parent)
self.initShape()
def init(self, parent):
self.heditor = parent
def initShape(self):
self.vbox = QVBoxLayout()
self.optab = QTabWidget()
self.fill = QWidget()
self.createHexOptions()
# self.createPageOptions()
self.createPixelOptions()
self.vbox.addWidget(self.optab)
self.createButtons()
self.vbox.addWidget(self.fill)
self.setLayout(self.vbox)
def createPageOptions(self):
self.pagegrid = QGridLayout()
self.pagegroup = QWidget()
pagelabel = QLabel("Page size : ")
self.sizeEdit = QFFSpinBox(self)
self.sizeEdit.setMaximum(self.heditor.filesize)
self.sizeEdit.setValue(self.heditor.pageSize)
# psize = QString("%.2d" % self.heditor.pageSize)
# self.sizeEdit.insert(psize)
headerlabel = QLabel("Header size : ")
self.headEdit = QFFSpinBox(self)
self.headEdit.setMaximum(self.heditor.filesize)
self.headEdit.setValue(self.heditor.pageHead)
# phead = QString("%.2d" % self.heditor.pageHead)
# self.headEdit.insert(phead)
sparelabel = QLabel("Spare size : ")
self.spareEdit = QFFSpinBox(self)
self.spareEdit.setMaximum(self.heditor.filesize)
self.spareEdit.setValue(self.heditor.pageSpare)
# pspare = QString("%.2d" % self.heditor.pageSpare)
# self.spareEdit.insert(pspare)
ppb = QLabel("Pages per block:")
self.pagesperblock = QComboBox()
self.pagesperblock.addItem("8")
self.pagesperblock.addItem("16")
self.pagesperblock.addItem("32")
self.pagesperblock.addItem("64")
self.pagesperblock.addItem("128")
self.pagesperblock.addItem("256")
self.pagesperblock.addItem("512")
self.pagesperblock.setCurrentIndex(2)
lview = QLabel("Left indication: ")
self.indic = QComboBox()
self.indic.addItem("Offset")
self.indic.addItem("Block")
# self.pagesperlineEdit = QLineEdit()
# ppl = QString("%.2d" % self.heditor.pagesPerBlock)
# self.pagesperlineEdit.insert(ppl)
self.pagegrid.addWidget(pagelabel, 0, 0)
self.pagegrid.addWidget(self.sizeEdit, 0, 1)
self.pagegrid.addWidget(headerlabel, 1, 0)
self.pagegrid.addWidget(self.headEdit, 1, 1)
self.pagegrid.addWidget(sparelabel, 2, 0)
self.pagegrid.addWidget(self.spareEdit, 2, 1)
self.pagegrid.addWidget(ppb, 3 ,0)
self.pagegrid.addWidget(self.pagesperblock, 3, 1)
self.pagegrid.addWidget(lview, 4, 0)
self.pagegrid.addWidget(self.indic, 4, 1)
self.pagegrid.addWidget(self.fill, 5, 0)
self.pagegrid.setRowStretch(5, 1)
# self.pagegrid.addWidget(self.fill, 6, 0)
# self.pagegrid.addWidget(pagesperline, 6, 0)
# self.pagegrid.addWidget(self.pagesperlineEdit, 7, 0)
self.pagegroup.setLayout(self.pagegrid)
self.vvbox.addWidget(self.pagegroup)
# self.optab.insertTab(1, self.pagegroup, "Pages" )
# self.vbox.addWidget(self.pagegroup)
def createHexOptions(self):
self.vvbox = QVBoxLayout()
self.vcontainer = QWidget()
self.hexgroup = QWidget()
self.hexgrid = QGridLayout()
groupebylabel = QLabel("Groupe by:")
self.groupeby = QComboBox()
self.groupeby.addItem("1")
self.groupeby.addItem("2")
self.groupeby.addItem("4")
offsetlabel = QLabel("Offset as")
self.offsetas = QComboBox()
self.offsetas.addItem("Hexadecimal")
self.offsetas.addItem("Decimal")
# self.hexgrid.addWidget(groupebylabel, 0, 0)
# self.hexgrid.addWidget(self.groupeby, 1, 0)
self.hexgrid.addWidget(offsetlabel, 0, 0)
self.hexgrid.addWidget(self.offsetas, 0, 1)
# self.hexgrid.addWidget(self.fill, 2, 0)
# self.hexgrid.setRowStretch(2, 1)
self.hexgroup.setLayout(self.hexgrid)
self.vvbox.addWidget(self.hexgroup)
self.createPageOptions()
self.vcontainer.setLayout(self.vvbox)
self.optab.insertTab(0, self.vcontainer, "General")
# self.vbox.addWidget(self.hexgroup)
#Offset as decimal / hexadecimal
def createPixelOptions(self):
self.pixgroup = QWidget()
self.pixgrid = QGridLayout()
formatlabel = QLabel("Format :")
self.format = QComboBox()
self.format.addItem("RGB")
self.format.addItem("Alpha RGB")
self.format.addItem("Indexed 8bit")
self.format.addItem("Mono")
self.connect(self.format, SIGNAL("currentIndexChanged(const QString)"), self.formatChanged)
colorlabel = QLabel("Indexed Color :")
self.icolor = QComboBox()
self.icolor.addItem("Green")
self.icolor.addItem("Red")
self.icolor.addItem("Blue")
self.icolor.addItem("Ascii")
self.icolor.addItem("256")
self.icolor.setEnabled(False)
slidelabel = QLabel("Resolution : ")
self.sliderspin = QSpinBox(self)
self.sliderspin.setMinimum(64)
self.sliderspin.setMaximum(1024)
self.sliderspin.setValue(self.heditor.wpixel.view.w)
self.connect(self.sliderspin, SIGNAL("valueChanged(int)"), self.slidermoved)
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(64)
self.slider.setMaximum(1024)
self.slider.setValue(self.heditor.wpixel.view.w)
self.slider.setSingleStep(1)
self.zoomlabel = QLabel("Scale factor : 1")
self.zoom = QSlider(Qt.Horizontal)
self.zoom.setMinimum(1)
self.zoom.setMaximum(5)
self.zoom.setValue(1)
self.zoom.setSingleStep(1)
self.zoom.setTickInterval(1)
self.zoom.setTickPosition(QSlider.TicksBelow)
self.connect(self.slider, SIGNAL("sliderMoved(int)"), self.slidermoved)
self.connect(self.zoom, SIGNAL("sliderMoved(int)"), self.scale)
self.pixgrid.addWidget(formatlabel, 0, 0)
self.pixgrid.addWidget(self.format, 0, 1)
self.pixgrid.addWidget(colorlabel, 1, 0)
self.pixgrid.addWidget(self.icolor, 1, 1)
self.pixgrid.addWidget(slidelabel, 2, 0)
self.pixgrid.addWidget(self.sliderspin, 2, 1, Qt.AlignLeft)
self.pixgrid.addWidget(self.slider, 3, 0)
self.pixgrid.addWidget(self.zoomlabel, 4, 0, Qt.AlignLeft)
self.pixgrid.addWidget(self.zoom, 5, 0)
self.pixgrid.addWidget(self.fill, 6, 0)
self.pixgrid.setRowStretch(6, 1)
self.pixgroup.setLayout(self.pixgrid)
self.optab.insertTab(1, self.pixgroup, "Pixel")
def setSliderLabel(self, value):
cvalue = QString()
cvalue = "%2.d" % value
self.sliderlabel.setText(cvalue)
def setZoomLabel(self, value):
zvalue = QString("Scale factor : ")
zvalue += "%2.d" % value
self.zoomlabel.setText(zvalue)
def createButtons(self):
self.applyB = QPushButton("Apply")
self.connect(self.applyB, SIGNAL('clicked()'), self.apply)
self.vbox.addWidget(self.applyB)
def checkValue(self, value):
try:
n = int(value)
return n
except ValueError:
return -1
def apply(self):
#PAGE CHECK
pagesize = self.sizeEdit.value()
headsize = self.headEdit.value()
sparesize = self.spareEdit.value()
pagesperblock = self.checkValue(self.pagesperblock.currentText())
if (pagesize < 0) or (headsize < 0) or (sparesize < 0) or (pagesperblock < 0):
print "Wrong values"
else:
offas = self.offsetas.currentText()
if offas == "Decimal":
self.heditor.decimalview = True
elif offas == "Hexadecimal":
self.heditor.decimalview = False
#Hexview refresh
self.heditor.readOffset(self.heditor.currentOffset)
#Pageview refresh
if self.indic.currentText() == "Offset":
self.heditor.pageOffView = True
else:
self.heditor.pageOffView = False
self.heditor.refreshPageValues(headsize, pagesize, sparesize, pagesperblock)
if self.heditor.wpage.scroll:
self.heditor.wpage.scroll.refreshValues(self.heditor.pagesPerBlock, self.heditor.pageSize)
self.heditor.wpage.view.refreshAllContent()
#PageView scrollbar refres
#Pixel View refresh
format = self.format.currentText()
if format == "Indexed 8bit":
self.heditor.wpixel.view.format = 0
elif format == "Mono":
self.heditor.wpixel.view.format = 1
elif format == "RGB":
self.heditor.wpixel.view.format = 2
elif format == "Alpha RGB":
self.heditor.wpixel.view.format = 3
if self.heditor.wpixel.scroll:
self.heditor.wpixel.scroll.refreshValues()
#Color
icolor = self.icolor.currentText()
if icolor == "Red":
self.heditor.wpixel.view.icolor = 0
elif icolor == "Green":
self.heditor.wpixel.view.icolor = 1
elif icolor == "Blue":
self.heditor.wpixel.view.icolor = 2
elif icolor == "Ascii":
self.heditor.wpixel.view.icolor = 3
elif icolor == "256":
self.heditor.wpixel.view.icolor = 4
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.read_image(pixoffset)
def slidermoved(self, value):
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.w = value
self.sliderspin.setValue(value)
# self.setSliderLabel(value)
self.heditor.wpixel.view.read_image(pixoffset)
if self.heditor.wpixel.scroll:
self.heditor.wpixel.scroll.refreshValues()
# print value
def scale(self, value):
self.setZoomLabel(value)
self.heditor.wpixel.view.scale = value
pixoffset = self.heditor.wpixel.view.currentOffset
self.heditor.wpixel.view.read_image(pixoffset)
def formatChanged(self, format):
if format == "Indexed 8bit":
self.icolor.setEnabled(True)
else:
self.icolor.setEnabled(False)
def keyPressEvent(self, kEvent):
key = kEvent.key()
if key == Qt.Key_Return or key == Qt.Key_Enter:
self.apply()
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 PlotLcm(QMainWindow):
""" A class to plot an LCM type over time. """
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle('LCM Plotter')
self.createMenu()
self.createMainFrame()
# Each channel has data and axis associated with it.
# Dictionary key is the channel name and property.
self.data = {}
self.axes = {}
self.lastPlot = None
# Stop the program if CTRL-C is received
self._stopEvent = threading.Event()
signal.signal(signal.SIGINT, self.handleSigint)
self._lcm = lcm.LCM()
self.handlerThread = threading.Thread(target=self.pollLcm)
self.handlerThread.setDaemon(True)
self.handlerThread.start()
self.connect(self, SIGNAL('redraw()'), self.on_draw) # Create redraw signal
self.drawingThread = threading.Thread(target=self.drawLoop)
self.drawingThread.setDaemon(True)
self.drawingThread.start()
def _cleanup(self):
self._stopEvent.set()
self.handlerThread.join()
self.drawingThread.join()
def handleSigint(self, *args):
self._cleanup()
QApplication.quit()
def pollLcm(self):
while not self._stopEvent.isSet():
rc = select.select([self._lcm.fileno()], [], [self._lcm.fileno()], 0.05)
if len(rc[0]) > 0 or len(rc[2]) > 0:
self._lcm.handle()
def drawLoop(self):
while not self._stopEvent.isSet():
self.emit(SIGNAL("redraw()"))
time.sleep(0.5)
def handleMessage(self, channel, msg):
for (lcmChannel, lcmType, lcmProperty) in self.data.keys():
if lcmChannel == channel:
data = eval(lcmType + ".decode(msg)." + lcmProperty)
self.data[(lcmChannel, lcmType, lcmProperty)].append(data)
def save_plot(self):
file_choices = "PNG (*.png)|*.png"
path = unicode(QFileDialog.getSaveFileName(self,
'Save file', '',
file_choices))
if path:
self.canvas.print_figure(path, dpi=self.dpi)
self.statusBar().showMessage('Saved to %s' % path, 2000)
def on_about(self):
msg = """ Plot an LCM message
"""
QMessageBox.about(self, "About the demo", msg.strip())
def on_draw(self):
""" Redraws the figure
"""
for (channel, lcmType, lcmProperty) in self.axes.keys():
axis = self.axes[(channel, lcmType, lcmProperty)]
axis.clear()
axis.grid(self.gridCheckBox.isChecked())
axis.plot(self.data[(channel, lcmType, lcmProperty)])
axis.set_title(channel + ": " + lcmProperty)
self.canvas.draw()
def addPlot(self):
channel = str(self.channelTextbox.text()).strip()
lcmType = str(self.typeTextbox.text()).strip()
lcmProperty = str(self.propertyTextbox.text()).strip()
if not self.checkInputs(channel, lcmType, lcmProperty):
return
self.data[(channel, lcmType, lcmProperty)] = []
n = len(self.data)
i = 0
self.fig.clear() # Clear the old plot first
for key in self.data.keys():
i = i + 1
self.axes[key] = self.fig.add_subplot(n, 1, i)
self.lastPlot = (channel, lcmType, lcmProperty)
self._lcm.subscribe(channel, self.handleMessage)
def clearPlots(self):
for key in self.data.keys():
self.data[key] = []
def checkInputs(self, channel, lcmType, lcmProperty):
# Error checking cause nobody is perfect...
if channel == "":
print "Warning: No channel given"
return False
try:
__import__("marof_lcm." + lcmType)
except ImportError:
print "Warning: The LCM type is not in scope"
return False
else:
try:
eval("getattr(" + lcmType + ", lcmProperty)")
except Exception:
print "Warning: The LCM property for this type does not exist"
return False
# Clear the data and don't create a new axis if there is already data for this
if self.data.has_key((channel, lcmType, lcmProperty)):
print "This data already exists:", channel
self.data[(channel, lcmType, lcmProperty)] = []
return False
return True
def createMainFrame(self):
self.mainFrame = QWidget()
self.dpi = 72
self.fig = Figure((5.0, 2.5), dpi=self.dpi, tight_layout=True)
self.canvas = FigureCanvasQTAgg(self.fig)
self.canvas.setParent(self.mainFrame)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.mpl_toolbar = NavigationToolbar2QTAgg(self.canvas, self.mainFrame)
# Other GUI controls
#
self.channelTextbox = QLineEdit()
self.channelTextbox.setMinimumWidth(100)
self.typeTextbox = QLineEdit()
self.typeTextbox.setMinimumWidth(100)
self.propertyTextbox = QLineEdit()
self.propertyTextbox.setMinimumWidth(100)
#self.connect(self.textbox, SIGNAL('editingFinished ()'), self.on_draw)
self.addPlotButton = QPushButton("Add Plot")
self.connect(self.addPlotButton, SIGNAL('clicked()'), self.addPlot)
self.mergePlotButton = QPushButton("Reset Data")
self.connect(self.mergePlotButton, SIGNAL('clicked()'), self.clearPlots)
self.gridCheckBox = QCheckBox("Show Grid")
self.gridCheckBox.setChecked(False)
self.connect(self.gridCheckBox, SIGNAL('stateChanged(int)'), self.on_draw)
slider_label = QLabel('Bar width (%):')
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(1, 100)
self.slider.setValue(20)
self.slider.setTracking(True)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.connect(self.slider, SIGNAL('valueChanged(int)'), self.on_draw)
#
# Layout with box sizers
#
hbox = QHBoxLayout()
for w in [self.channelTextbox, self.typeTextbox, self.propertyTextbox,
self.addPlotButton, self.mergePlotButton, self.gridCheckBox,
slider_label, self.slider]:
hbox.addWidget(w)
hbox.setAlignment(w, Qt.AlignVCenter)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox.addWidget(self.mpl_toolbar)
vbox.addLayout(hbox)
self.mainFrame.setLayout(vbox)
self.setCentralWidget(self.mainFrame)
def createMenu(self):
# File menu
fileMenu = self.menuBar().addMenu("File")
saveMenuItem = self.create_action("&Save plot",
shortcut="Ctrl+S", slot=self.save_plot,
tip="Save the plot")
quitAction = self.create_action("&Quit", slot=self.close,
shortcut="Ctrl+Q", tip="Close the application")
self.add_actions(fileMenu,
(saveMenuItem, None, quitAction))
# Help menu
helpMenu = self.menuBar().addMenu("Help")
aboutAction = self.create_action("&About",
shortcut='F1', slot=self.on_about,
tip='About the demo')
self.add_actions(helpMenu, (aboutAction,))
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_action( self, text, slot=None, shortcut=None,
icon=None, tip=None, checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def closeEvent(self, event):
self._cleanup() # stop the drawing thread before exiting
event.accept()
class OpencvCameraTestWidget(QWidget):
available_resolutions = {
"160x120": [160, 120],
"176x144": [176, 144],
"320x240": [320, 240],
"352x288": [352, 288],
"640x480": [640, 480],
"960x720": [960, 720],
"1280x960": [1280, 960]
}
def __init__(self, parent=None, capture=None, widget=None):
super(OpencvCameraTestWidget, self).__init__(parent)
self.main_layout = QVBoxLayout(self)
self.main_layout.setSizeConstraint(QLayout.SetFixedSize)
if capture is None:
self.capture = cv2.VideoCapture(0)
else:
self.capture = capture
if widget is None:
self.camera_widget = QImageWidget()
self.main_layout.addWidget(self.camera_widget)
self.camera_ret = 0
self.raw_camera_image = None
# cv2.namedWindow("image")
self.camera_timer = QTimer()
self.camera_timer.timeout.connect(self.grab_video)
self.camera_timer.start(1000 / 24)
self.brightness_layout = QHBoxLayout()
self.brightness_label = QLabel("Brightness: ")
self.brightness_layout.addWidget(self.brightness_label)
self.brightness_value_label = QLabel("")
self.brightness_value_label.setMinimumWidth(30)
self.brightness_slider = QSlider(Qt.Horizontal)
self.brightness_slider.setFocusPolicy(Qt.StrongFocus)
self.brightness_slider.setTickPosition(QSlider.TicksBothSides)
self.brightness_slider.setMinimum(-10)
self.brightness_slider.setMaximum(110)
self.brightness_slider.setValue(20)
self.brightness_slider.setTickPosition(QSlider.TicksBelow)
self.brightness_slider.setTickInterval(10)
self.brightness_slider.valueChanged.connect(self.set_brightness)
self.brightness_layout.addWidget(self.brightness_slider)
self.brightness_layout.addWidget(self.brightness_value_label)
self.main_layout.addLayout(self.brightness_layout)
self.contrast_layout = QHBoxLayout()
self.contrast_label = QLabel("Contrast: ")
self.contrast_layout.addWidget(self.contrast_label)
self.contrast_value_label = QLabel("")
self.contrast_value_label.setMinimumWidth(30)
self.contrast_slider = QSlider(Qt.Horizontal)
self.contrast_slider.setFocusPolicy(Qt.StrongFocus)
self.contrast_slider.setTickPosition(QSlider.TicksBothSides)
self.contrast_slider.setMinimum(-10)
self.contrast_slider.setMaximum(110)
self.contrast_slider.setValue(20)
self.contrast_slider.setTickPosition(QSlider.TicksBelow)
self.contrast_slider.setTickInterval(10)
self.contrast_slider.valueChanged.connect(self.set_contrast)
self.contrast_layout.addWidget(self.contrast_slider)
self.contrast_layout.addWidget(self.contrast_value_label)
self.main_layout.addLayout(self.contrast_layout)
self.exposure_layout = QHBoxLayout()
self.exposure_label = QLabel("Exposure: ")
self.exposure_layout.addWidget(self.exposure_label)
self.exposure_value_label = QLabel("")
self.exposure_value_label.setMinimumWidth(30)
self.exposure_slider = QSlider(Qt.Horizontal)
self.exposure_slider.setFocusPolicy(Qt.StrongFocus)
self.exposure_slider.setTickPosition(QSlider.TicksBothSides)
self.exposure_slider.setMinimum(-10)
self.exposure_slider.setMaximum(110)
self.exposure_slider.setValue(20)
self.exposure_slider.setTickPosition(QSlider.TicksBelow)
self.exposure_slider.setTickInterval(10)
self.exposure_slider.valueChanged.connect(self.set_exposure)
self.exposure_layout.addWidget(self.exposure_slider)
self.exposure_layout.addWidget(self.exposure_value_label)
self.main_layout.addLayout(self.exposure_layout)
self.iso_layout = QHBoxLayout()
self.iso_label = QLabel("ISO: ")
self.iso_layout.addWidget(self.iso_label)
self.iso_value_label = QLabel("")
self.iso_value_label.setMinimumWidth(30)
self.iso_slider = QSlider(Qt.Horizontal)
self.iso_slider.setFocusPolicy(Qt.StrongFocus)
self.iso_slider.setTickPosition(QSlider.TicksBothSides)
self.iso_slider.setMinimum(-10)
self.iso_slider.setMaximum(110)
self.iso_slider.setValue(20)
self.iso_slider.setTickPosition(QSlider.TicksBelow)
self.iso_slider.setTickInterval(10)
self.iso_slider.valueChanged.connect(self.set_iso)
self.iso_layout.addWidget(self.iso_slider)
self.iso_layout.addWidget(self.iso_value_label)
self.main_layout.addLayout(self.iso_layout)
self.auto_exposure_label = QLabel("AutoExposure: ")
self.auto_exposure_checkbox = QCheckBox("AutoExposure: ")
self.exposure_layout.addWidget(self.auto_exposure_checkbox)
self.auto_exposure_checkbox.stateChanged.connect(
self.set_auto_exposure)
self.resolutions_combo = QComboBox()
self.resolutions_combo.addItems(self.available_resolutions.keys())
self.main_layout.addWidget(self.resolutions_combo)
self.resolutions_combo.currentIndexChanged[str].connect(
self.set_resolution)
def set_brightness(self, value):
self.capture.set(cv2.CAP_PROP_BRIGHTNESS, value / 100.0)
self.brightness_value_label.setText(str(value / 100.0))
def set_contrast(self, value):
self.capture.set(cv2.CAP_PROP_CONTRAST, value / 100.0)
self.contrast_value_label.setText(str(value / 100.0))
def set_exposure(self, value):
self.capture.set(cv2.CAP_PROP_EXPOSURE, value / 100.0)
self.exposure_value_label.setText(str(value / 100.0))
def set_iso(self, value):
self.capture.set(cv2.CAP_PROP_ISO_SPEED, value / 100.0)
self.exposure_value_label.setText(str(value / 100.0))
def set_auto_exposure(self, value):
if value > 0:
self.capture.set(cv2.CAP_PROP_AUTO_EXPOSURE, 1)
else:
self.capture.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0.25)
def set_resolution(self, string):
if str(string) in self.available_resolutions:
height = self.available_resolutions[str(string)][0]
width = self.available_resolutions[str(string)][1]
self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, width)
def grab_video(self):
# print "grab video"
self.camera_ret, self.raw_camera_image = self.capture.read()
if self.camera_ret:
self.raw_camera_image = cv2.cvtColor(self.raw_camera_image,
cv2.COLOR_BGR2RGB)
self.camera_widget.set_opencv_image(self.raw_camera_image)
class Simulator(QMainWindow):
def __init__(self, network):
super(Simulator, self).__init__()
x, y, w, h = 100, 100, 800, 500
self.setGeometry(x, y, w, h)
# Network
self.network = network
# Canvas
self.canvas = Canvas()
#Controls
self.slider = QSlider(Qt.Horizontal, self)
self.slider.setMaximum(self.network.count_snapshots()-1)
self.slider.setTickPosition(QSlider.TicksBelow)
self.slider.setTickInterval(1)
self.connect(self.slider, SIGNAL("valueChanged(int)"), self.draw_network)
self.prevButton = QPushButton(u"\u25C0")
self.connect(self.prevButton, SIGNAL("clicked()"), self.onClickPrev)
self.nextButton = QPushButton(u"\u25B6")
self.connect(self.nextButton, SIGNAL("clicked()"), self.onClickNext)
controls = QHBoxLayout()
controls.addWidget(self.prevButton)
controls.addWidget(self.slider)
controls.addWidget(self.nextButton)
#Main Layout
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.canvas)
mainLayout.addLayout(controls)
self.widget = QtGui.QWidget()
self.widget.setLayout(mainLayout)
self.setCentralWidget(self.widget)
self.setWindowTitle('DATK Simulator')
#Reset Network and draw in starting state
self.draw_network(0)
def draw_network(self, value):
self.network.restore_snapshot(value)
self.canvas.draw(self.network)
def onClickPrev(self):
v = self.slider.value()
if v > 0:
self.slider.setValue(v-1)
def onClickNext(self):
v = self.slider.value()
if v < self.slider.maximum():
self.slider.setValue(v+1)
def closeEvent(self, event):
self.network.restore_snapshot(-1)
self.deleteLater()
class MainWin(QMainWindow):
def __init__(self, mx, spurs, fef, parent=None, plot_lib='mpl'):
QMainWindow.__init__(self, parent)
self.mx = mx
self.spurset = spurs
self.fef = fef
if plot_lib == 'qwt':
from chart.qwtchart import qwtchart as chart
elif plot_lib == 'mpl':
from chart.mplchart import mplchart as chart
elif plot_lib == 'pg':
from chart.pyqtgraphchart import pyqtgraphchart as chart
else:
raise NotImplementedError
self.chart = chart(self.spurset, self.fef, self)
self.create_menu_bar()
self.create_main_frame()
self.hookup()
def hookup(self):
# connect all the objects that are supposed to be watching each other
# for changes and updates.
self.mx.register(self.chart.draw_spurs)
self.spurset.register(self.chart.draw_spurs)
self.chart.picker_watch(self.fef)
self.fef.register(self.chart.draw_fef)
self.chart.draw_spurs(self.spurset)
self.chart.draw_fef(self.fef)
def IF_slide(self, i):
""" callback method for the IF selection slider"""
self.IFtextbox.setText(str(i))
self.mx.IF = i
def about(self):
msg = '''
A frequency-planing tool based on the method of spur distances.
(A reference to the article will go here)
For more info, view the README included with this program.
Patrick Yeon, 2012'''
QMessageBox.about(self, 'Spur Distance Chart', msg.strip())
def mxtypecb(self, i):
""" callback method for mixer configuration selection combobox"""
self.mx.m, self.mx.n = [(-1, 1), (1, -1), (1,1)][i]
# trigger anything watching the mixer
self.mx.update_watchers()
def create_main_frame(self):
self.main_frame = QWidget()
# Looking at the main frame as two columns. On the left there is the
# chart and the IF control. In the right column we'll have range
# settings, mixer settings, and maybe other stuff that comes up?
self.IFtextbox = QLineEdit()
self.IFtextbox.setMinimumWidth(6)
self.IFtextbox.setText(str(self.spurset.mixer.IF))
# TODO link up the textbox so that it can also be input
self.IFslider = QSlider(Qt.Horizontal)
# TODO I'd really like some form of slider that doesn't actually limit
# the user. Also, if IFtextbox could modify the IF, that'd be nice.
self.IFslider.setRange(int(self.mx.IF * 0.1), (self.mx.IF * 5))
self.IFslider.setValue(self.mx.IF)
self.IFslider.setTracking(True)
self.IFslider.setTickPosition(QSlider.TicksAbove)
step = max(1, int(0.01 * self.mx.IF))
self.IFslider.setSingleStep(step)
self.IFslider.setPageStep(step * 10)
self.IFcid = self.connect(self.IFslider, SIGNAL('valueChanged(int)'),
self.IF_slide)
IFbar = QHBoxLayout()
IFbar.addWidget(QLabel('IF'))
IFbar.addWidget(self.IFtextbox)
IFbar.addWidget(self.IFslider)
IFbar.addStretch()
leftcol = QVBoxLayout()
leftcol.addWidget(self.chart.plot)
leftcol.addLayout(IFbar)
# left column done. Now the right-hand side
rangebox = QVBoxLayout()
for (prop, name, f) in [(spurset.RFmin, 'RFmin', self.spurset.RFmin),
(spurset.RFmax, 'RFmax', self.spurset.RFmax),
(spurset.dspan, 'dspan', self.spurset.dspan)]:
rangebox.addLayout(Fbar(self.spurset, prop,
name, f, 0, 10000))
autocb = QCheckBox('Auto')
# Disable it, won't be implemented for release
# but leave it there, to nag me into doing it.
autocb.setDisabled(True)
rangebox.addWidget(autocb)
# a line to report the front-end filter's limits
fefstat = QHBoxLayout()
fefstat.addWidget(QLabel('Filter Range: '))
fefrange = QLabel('%d - %d' % (self.fef.start, self.fef.stop))
# TODO not sure about the lambda here. Feels like if I give it time,
# I'll sort out a sensible overall connection scheme.
self.fef.register(lambda o: fefrange.setText('%d - %d' %
(self.fef.start,
self.fef.stop)))
fefstat.addWidget(fefrange)
# mixer high/low-side injection picker
mxbar = QHBoxLayout()
mxbar.addWidget(QLabel('IF = '))
mxtype = QComboBox()
mxtype.addItem('LO - RF')
mxtype.addItem('RF - LO')
mxtype.addItem('RF + LO')
# TODO this is ugly
mxtype.setCurrentIndex([(-1, 1), (1, -1), (1,1)].index((self.mx.m,
self.mx.n)))
self.mxtypecid = self.connect(mxtype,
SIGNAL('currentIndexChanged(int)'),
self.mxtypecb)
mxbar.addWidget(mxtype)
# alright, the actual column proper in the layout
vbar = QVBoxLayout()
vbar.addLayout(rangebox)
vbar.addLayout(fefstat)
vbar.addLayout(mxbar)
legend = self.chart.legend()
vbar.addWidget(legend)
# need to let the legend stretch so that everything fits in it
vbar.setStretchFactor(legend, 1)
vbar.addStretch()
hbox = QHBoxLayout()
hbox.addLayout(leftcol)
hbox.addLayout(vbar)
# make sure the legend doesn't stretch so far horizontally that the
# chart suffers considerable loss of space.
hbox.setStretchFactor(leftcol, 5)
hbox.setStretchFactor(vbar, 1)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
def create_menu_bar(self):
filemenu = self.menuBar().addMenu('&File')
close = QAction('&Quit', self)
close.setShortcut('Ctrl+W')
self.connect(close, SIGNAL('triggered()'), self.close)
filemenu.addAction(close)
helpmenu = self.menuBar().addMenu('&Help')
about = QAction('&About', self)
about.setShortcut('F1')
self.connect(about, SIGNAL('triggered()'), self.about)
helpmenu.addAction(about)
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()
def __init__(self,model):
super(QWidget,self).__init__()
if not isinstance(model,Model):
raise Exception('Constructor argument of type Model expected.')
self.setWindowTitle('Strandbeest simulator')
# lazily simulates on full movement cycle of the strandbeest
def iterateStates():
'''
Iterates over the first full movement cycle of the Strandbeest.
In order to determine when the movement repeats, a heuristic is
used, that stops simulating once the state vector becomes similar
enough to the initial state vector. This heuristic assumes that
the movement of the Strandbeest is time independent.
'''
x0 = model.state()
yield x0
for _ in range(2):
model.increment(0.01)
xi = model.state()
yield xi
limit = norm(xi-x0)
while True:
model.increment(0.01)
xi = model.state()
yield xi
if norm(xi-x0) < limit: # <- heuristic condition for a full simulation cycle
break
# record simulation results
record = _Record()
view = _View(model,record)
def recordStates(states):
'''
The _Canvas uses the states of the simulation to display movement curves of
the nodes. For that purposes the simulated states are stored to the model in
the record.states list.
In order to notify the _View of newly simulated states, all callables in
the record.changeListeners list are notified, with the new state vector as
argument.
'''
for x in states:
record.states.append(x)
record.velocities.append( model.v(x,t=None) )
record.times.append( model.t )
for listener in record.changeListeners:
listener(x)
yield x
del record.changeListeners
def recordSceenshots(statesLoop):
'''
A little utility i created to be able to generate GIFs from
the simulation. Saves screenshots from the current view of
every 10th simulation step.
'''
i,j = 0,0
for x in statesLoop:
if i < 2*943 and 0 == i % 10:
img = QPixmap.grabWidget(self)
img = img.scaled(640,500,transformMode = Qt.SmoothTransformation)
img.save('data/img%(j)d.jpg' % locals(),'jpg')
j+=1
i += 1
yield x
statesLoop = iterateStates()
statesLoop = recordStates(statesLoop)
statesLoop = itertools.cycle(statesLoop)
# statesLoop = recordSceenshots(statesLoop)
def tick():
'''
Advances the view by one tick (not neccessarily the simulation)
'''
model.setState( next(statesLoop) ) # <- in the first cycle this statement is redundant
tick()
timer = QTimer()
timer.timeout.connect(tick)
speedLabel = QLabel('? * Realtime')
speedLabel.resize(speedLabel.sizeHint())
speedLabel.setToolTip('Simulation speed [ticks/sec.].')
speedSlider = QSlider(Qt.Horizontal)
speedSlider.resize(speedSlider.sizeHint())
speedSlider.setMinimum(0)
speedSlider.setMaximum(6)
speedSlider.setTickPosition(QSlider.TicksBelow)
def tpsChange(value): # <- called whenever ticks/sec. change
'''
Changes the number of simulation ticks per second.
'''
value = 2**(value-2)
speedLabel.setText( '%(value)6.2f * Realtime' % locals() )
timer.setInterval(10/value)
speedSlider.valueChanged[int].connect(tpsChange)
speedSlider.setValue(4)
def startStopClick():
startStopClick.running ^= True
if startStopClick.running:
timer.start()
startStop.setText('Stop')
else:
timer.stop()
startStop.setText('Start')
startStop = QPushButton('Start/Stop')
startStop.resize(startStop.sizeHint())
startStop.setToolTip('Start the simulation.')
startStop.clicked.connect(startStopClick)
startStopClick.running = True
startStopClick()
grid = QGridLayout(self)
grid.addWidget(startStop,0,0)
grid.addWidget(speedSlider,0,1)
grid.addWidget(speedLabel,0,2)
grid.addWidget(view,1,0,1,3)
class LogDialog(QDialog):
"""LogDialog for the Freeseer project.
It is the dialog window for the log.
There is an instance for every FreeseerApp.
It has a LogHandler which calls LogDialog's
message() method when a new log message is received.
The call to message() causes a call to add_entry()
which adds the information to a new row in the table.
"""
def __init__(self, parent=None):
super(LogDialog, self).__init__(parent)
self.resize(800, 500)
self.app = QApplication.instance()
icon = QIcon()
icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
layout = QVBoxLayout()
self.setLayout(layout)
self.level = 0
self.handler = LogHandler()
self.table_model = QStandardItemModel(0, 5)
header_names = ["Date", "Level", "Module", "Message", "LevelNo"]
date_column = header_names.index("Date")
level_column = header_names.index("Level")
module_column = header_names.index("Module")
self.level_num_column = header_names.index("LevelNo")
self.table_model.setHorizontalHeaderLabels(header_names)
self.table_view = QTableView()
self.table_view.setModel(self.table_model)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.setColumnWidth(date_column, 125)
self.table_view.setColumnWidth(level_column, 60)
self.table_view.setColumnWidth(module_column, 250)
self.table_view.setColumnHidden(self.level_num_column, True)
self.table_view.setShowGrid(False)
self.table_view.horizontalHeader().setClickable(False)
self.table_view.verticalHeader().hide()
self.table_view.setStyleSheet("""Qtable_view::item {
border-bottom: 1px solid lightgrey;
selection-background-color: white;
selection-color: black;
}""")
top_panel = QHBoxLayout()
self.log_levels = ["Debug", "Info", "Warning", "Error"]
self.level_colors = ["#3E4C85", "#269629", "#B0AB21", "#B32020"]
self.levels_label = QLabel("Filter Level: ")
self.levels_label.setStyleSheet("QLabel { font-weight: bold }")
self.current_level_label = QLabel(self.log_levels[0])
self.current_level_label.setStyleSheet("QLabel {{ color: {} }}".format(self.level_colors[0]))
self.clear_button = QPushButton("Clear Log")
self.levels_slider = QSlider(Qt.Horizontal)
self.levels_slider.setStyleSheet("""
QSlider::handle:horizontal {
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
stop:0 #FFFFFF, stop:1 #E3E3E3);
border: 1px solid #707070;
width: 10px;
margin-top: -4px;
margin-bottom: -4px;
border-radius: 4px;
}
QSlider::handle:horizontal:hover {
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
stop:0 #DEDEDE, stop:1 #C9C9C9);
border: 1px solid #4F4F4F;
border-radius: 4px;
}
QSlider::sub-page:horizontal {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #BFBFBF, stop: 1 #9E9E9E);
background: qlineargradient(x1: 0, y1: 0.2, x2: 1, y2: 1,
stop: 0 #9E9E9E, stop: 1 #858585);
border: 1px solid #777;
height: 10px;
border-radius: 4px;
}
QSlider::add-page:horizontal {
background: #fff;
border: 1px solid #707070;
height: 10px;
border-radius: 4px;
}""")
self.levels_slider.setRange(0, len(self.log_levels) - 1)
self.levels_slider.setTickPosition(QSlider.TicksBelow)
self.levels_slider.setTickInterval(1)
top_panel.addSpacerItem(QSpacerItem(10, 0))
top_panel.addWidget(self.levels_label, 3)
top_panel.addWidget(self.current_level_label, 2)
top_panel.addWidget(self.levels_slider, 8)
top_panel.addSpacerItem(QSpacerItem(25, 0))
top_panel.addWidget(self.clear_button, 10)
layout.addLayout(top_panel)
layout.addWidget(self.table_view)
self.connect(self.clear_button, SIGNAL('clicked()'), functools.partial(self.table_model.setRowCount, 0))
self.connect(self.levels_slider, SIGNAL('valueChanged(int)'), self.slider_set_level)
self.setWindowTitle("Log")
self.handler.add_listener(self)
def __del__(self):
self.handler.remove_listener(self)
def retranslate(self):
self.setWindowTitle(self.app.translate("LogDialog", "Log"))
self.clear_button.setText(self.app.translate("LogDialog", "Clear Log"))
self.levels_label.setText("{}: ".format(self.app.translate("LogDialog", "Filter Level")))
def message(self, message):
"""Passes the log fields to add_entry()
It is called by LogHandler when a log message is received"""
self.add_entry(message["time"], message["level"], message["full_module_name"], message["message"], str(message["levelno"]))
def add_entry(self, date, level, module, message, levelno):
"""Adds the given fields to a new row in the log table
It is called by message() when a log message is received"""
items = [QStandardItem(date), QStandardItem(level), QStandardItem(module), QStandardItem(message), QStandardItem(levelno)]
for item in items:
item.setEditable(False)
self.table_model.appendRow(items)
def slider_set_level(self, level):
self.current_level_label.setText(self.log_levels[level])
self.current_level_label.setStyleSheet("QLabel {{ color: {} }}".format(self.level_colors[level]))
self.set_level(level + 1)
def set_level(self, level):
"""Sets the current level of the LogDialog.
Level is based on the selection made in the levels_combo_box.
It hides all messages with a lower level."""
self.level = level * 10
for i in range(self.table_model.rowCount()):
if int(str(self.table_model.item(i, self.level_num_column).text())) < self.level:
self.table_view.setRowHidden(i, True)
else:
self.table_view.setRowHidden(i, False)
class Tool(QToolBar):
def __init__(self,parent):
QToolBar.__init__(self,parent)
self.parent = parent
self.action_NewProject = QAction(Icons.newprj, 'Project', self)
self.action_NewProject.triggered.connect(self.parent.treeWidget.newProject)
self.action_NewProject.setToolTip("Create a New Project")
self.action_Open = QAction(Icons.open, 'Open', self)
self.action_Open.triggered.connect(self.parent.fileOpen)
self.action_Open.setToolTip("Open File")
self.action_Save = QAction(Icons.save, 'Save', self)
self.action_Save.setShortcut('Ctrl+S')
self.action_Save.triggered.connect(self.parent.fileSave)
self.action_Save.setToolTip("Save Current File")
self.action_SaveAll = QAction(Icons.saveall, 'SaveAll', self)
self.action_SaveAll.setShortcut('Ctrl+A')
self.action_SaveAll.triggered.connect(self.parent.fileSaveAll)
self.action_SaveAll.setToolTip("Save All Files")
self.action_Build = QAction(Icons.thread_view, 'Build', self)
self.action_Build.setShortcut('Ctrl+B')
self.action_Build.triggered.connect(self.parent.build_project)
self.action_Debug = QAction(Icons.debug_exec, 'Debug', self)
self.action_Refresh = QAction(Icons.refresh_tab, 'Refresh', self)
self.action_Refresh.triggered.connect(self.parent.treeWidget.refreshCurrentProject)
self.action_Run = QAction(Icons.run, 'Run', self)
self.action_Run.setShortcut('Ctrl+R')
self.action_Run.triggered.connect(self.parent.adb.run)
self.action_RunFile = QAction(Icons.go, 'Cmd', self)
self.action_RunFile.triggered.connect(self.parent.openCommand)
self.parent.runButton.clicked.connect(self.parent.command.setCmdLine)
self.action_Stop = QAction(Icons.stop, 'Stop', self)
self.action_Stop.setShortcut('Ctrl+Q')
self.action_Stop.triggered.connect(self.parent.adb.stop)
self.action_Design = QAction(Icons.color_palette, 'Design', self)
self.action_Design.triggered.connect(self.parent.design)
self.action_Level = QAction(Icons.cmpC_pal, 'Level', self)
self.action_Level.triggered.connect(self.parent.level)
self.action_Todo = QAction(Icons.task_set, 'Todo', self)
self.action_Todo.triggered.connect(self.parent.todo)
self.action_Help = QAction(Icons.toc_open, 'Help', self)
self.action_Help.triggered.connect(self.parent.help)
men = QMenu()
#Threshold Slider
self.threshSlider = QSlider()
self.threshSlider.setTickPosition(QSlider.TicksLeft)
self.threshSlider.setOrientation(Qt.Horizontal)
self.threshSlider.setValue(config.thresh())
self.threshSlider.setMinimum(0)
self.threshSlider.setMaximum(5)
self.threshSlider.valueChanged.connect(self.parent.setThreshold)
self.threshSliderAction = QWidgetAction(men)
self.threshSliderAction.setDefaultWidget(self.threshSlider)
#TabsWidth Slider
self.tabsSlider = QSlider()
self.tabsSlider.setTickPosition(QSlider.TicksLeft)
self.tabsSlider.setOrientation(Qt.Horizontal)
self.tabsSlider.setValue(config.tabwidth())
self.tabsSlider.setMinimum(0)
self.tabsSlider.setMaximum(8)
self.tabsSlider.valueChanged.connect(self.parent.setTabWidth)
self.tabsSliderAction = QWidgetAction(men)
self.tabsSliderAction.setDefaultWidget(self.tabsSlider)
#iconSize Slider
self.iconSlider = QSlider()
self.iconSlider.setTickPosition(QSlider.TicksLeft)
self.iconSlider.setOrientation(Qt.Horizontal)
self.iconSlider.setValue(config.iconSize())
self.iconSlider.setMinimum(16)
self.iconSlider.setMaximum(32)
self.iconSlider.setSingleStep(2)
self.iconSlider.valueChanged.connect(self.setIcon)
self.iconSliderAction = QWidgetAction(men)
self.iconSliderAction.setDefaultWidget(self.iconSlider)
'''Font Button'''
self.fontCombo = QFontComboBox()
self.fontCombo.currentFontChanged.connect(self.parent.setFont)
self.fontCombo.setCurrentFont(QFont(config.fontName()))
self.fontComboMenu = QWidgetAction(men)
self.fontComboMenu.setDefaultWidget(self.fontCombo)
'''Font Size'''
self.fontSizeCombo = QComboBox()
for size in range(1,40):
self.fontSizeCombo.addItem(str(size))
self.fontSizeCombo.setCurrentIndex(config.fontSize())
self.fontSizeCombo.currentIndexChanged.connect(self.parent.setFontSize)
self.fontSizeComboMenu = QWidgetAction(men)
self.fontSizeComboMenu.setDefaultWidget(self.fontSizeCombo)
action_explorer = QAction("Show Explorer",self)
action_explorer.triggered.connect(self.parent.exp)
action_console = QAction("Show Console",self)
action_console.triggered.connect(self.parent.cmd)
action_designer = QAction("Show Designer",self)
action_designer.triggered.connect(self.parent.design)
action_Indentation = QAction("Indentation Guides",self)
action_Indentation.triggered.connect(self.parent.setIndent)
action_WhiteSpace = QAction("Show WhiteSpace",self)
action_WhiteSpace.triggered.connect(self.parent.setWhiteSpace)
action_EndLine = QAction("Show End of Lines",self)
action_EndLine.triggered.connect(self.parent.setEndLine)
action_Margin = QAction("Line Numbers",self)
action_Margin.triggered.connect(self.parent.setMargin)
action_ToolLabel = QAction("Tool Labels",self)
action_ToolLabel.triggered.connect(self.setToolLabel)
action_Android = QAction(Icons.android,'Android', self)
action_Android.triggered.connect(self.parent.android)
action_Ant = QAction(Icons.ant_view,'Ant', self)
action_Ant.triggered.connect(self.parent.antt)
action_Squirrel = QAction(Icons.nut,'Squirrel', self)
action_Squirrel.triggered.connect(self.parent.squirrel)
action_Ios1 = QAction(Icons.ios,'iOS', self)
action_Update = QAction("Update",self)
action_Update.triggered.connect(self.parent.update)
'''Encoding'''
encodingGroup = QActionGroup(self)
encodingGroup.setExclusive(True)
action_Ascii = QAction("Ascii",encodingGroup)
action_Ascii.setCheckable(True)
action_Unicode = QAction("Unicode",encodingGroup)
action_Unicode.setCheckable(True)
encodingGroup.addAction(action_Ascii)
encodingGroup.addAction(action_Unicode)
encodingGroup.selected.connect(self.parent.setEncoding)
if(config.encoding() == Encoding.ASCII):
action_Ascii.setChecked(True)
else:
action_Unicode.setChecked(True)
men.addAction(action_Android)
men.addAction(action_Ant)
men.addAction(action_Squirrel)
men.addAction(action_Ios1)
men.addAction(action_Update)
men.addSeparator()
men.addAction(action_explorer)
men.addAction(action_console)
men.addAction(action_designer)
men.addAction(action_Indentation)
men.addAction(action_WhiteSpace)
men.addAction(action_EndLine)
men.addAction(action_Margin)
men.addAction(action_ToolLabel)
men.addSeparator()
men.addActions(encodingGroup.actions())
men.addSeparator()
head_font = QLabel("Font---------------------")
fnt = head_font.font()
fnt.setBold(True)
head_font.setFont(fnt)
head_fontWidgetAction = QWidgetAction(men)
head_fontWidgetAction.setDefaultWidget(head_font)
men.addAction(head_fontWidgetAction)
men.addAction(self.fontComboMenu)
men.addAction(self.fontSizeComboMenu)
men.addSeparator()
men.addAction(QAction("TabWidth",self))
men.addAction(self.tabsSliderAction)
men.addSeparator()
men.addAction(QAction("Threshold",self))
men.addAction(self.threshSliderAction)
#men.addAction(QAction("Icon Size",self))
#men.addAction(self.iconSliderAction)
self.action_Options = QAction(Icons.emblem_system, 'Options', self)
self.action_Options.setMenu(men)
self.action_Full = QAction(Icons.fullscreen, 'Full', self)
self.action_Full.setShortcut('Shift+Enter')
self.action_Full.triggered.connect(self.parent.full)
self.modeGroup = QActionGroup(self)
self.modeGroup.setExclusive(True)
self.modeGroup.selected.connect(self.parent.setMode)
self.action_Squirrel = QAction(Icons.nut, 'Squ', self.modeGroup)
self.action_Squirrel.setCheckable(True)
self.action_Emo = QAction(Icons.emo, 'Emo', self.modeGroup)
self.action_Emo.setCheckable(True)
self.action_And = QAction(Icons.android, 'Android', self.modeGroup)
self.action_And.setCheckable(True)
self.action_Ios = QAction(Icons.ios, 'ios', self.modeGroup)
self.action_Ios.setCheckable(True)
self.modeGroup.addAction(self.action_Squirrel)
self.modeGroup.addAction(self.action_Emo)
self.modeGroup.addAction(self.action_And)
self.modeGroup.addAction(self.action_Ios)
self.action_Style = QAction(Icons.style, 'Style', self)
men1 = QMenu()
self.styleslist = []
self.style1 = QAction("All Hallow's Eve",self)
self.style1.triggered.connect(lambda:self.parent.style_clicked(1))
self.style1.setCheckable(True)
self.style2 = QAction("Amy",self)
self.style2.triggered.connect(lambda:self.parent.style_clicked(2))
self.style2.setCheckable(True)
self.style3 = QAction("Aptana Studio",self)
self.style3.triggered.connect(lambda:self.parent.style_clicked(3))
self.style3.setCheckable(True)
self.style4 = QAction("Bespin",self)
self.style4.triggered.connect(lambda:self.parent.style_clicked(4))
self.style4.setCheckable(True)
self.style5 = QAction("Blackboard",self)
self.style5.triggered.connect(lambda:self.parent.style_clicked(5))
self.style5.setCheckable(True)
self.style6 = QAction("Choco",self)
self.style6.triggered.connect(lambda:self.parent.style_clicked(6))
self.style6.setCheckable(True)
self.style7 = QAction("Cobalt",self)
self.style7.triggered.connect(lambda:self.parent.style_clicked(7))
self.style7.setCheckable(True)
self.style8 = QAction("Dawn",self)
self.style8.triggered.connect(lambda:self.parent.style_clicked(8))
self.style8.setCheckable(True)
self.style9 = QAction("Eclipse",self)
self.style9.triggered.connect(lambda:self.parent.style_clicked(9))
self.style9.setCheckable(True)
self.styleslist.append(self.style1)
self.styleslist.append(self.style2)
self.styleslist.append(self.style3)
self.styleslist.append(self.style4)
self.styleslist.append(self.style5)
self.styleslist.append(self.style6)
self.styleslist.append(self.style7)
self.styleslist.append(self.style8)
self.styleslist.append(self.style9)
men1.addActions(self.styleslist)
self.action_Style.setMenu(men1)
self.styleslist[self.parent.styleIndex].setChecked(True)
self.action_Stop.setDisabled(True)
self.setToolLabel()
self.setAllowedAreas(Qt.AllToolBarAreas)
#self.setFixedHeight(40)
#self.setIconSize(QSize(config.iconSize(),config.iconSize()))
self.addAction(self.action_NewProject)
self.addAction(self.action_Open)
self.addAction(self.action_Save)
self.addAction(self.action_SaveAll)
#self.addAction(self.action_Refresh)
self.addSeparator()
self.addAction(self.action_Build)
self.addAction(self.action_Run)
self.addAction(self.action_RunFile)
self.addAction(self.action_Stop)
self.addAction(self.action_Debug)
self.addSeparator()
self.addAction(self.action_Design)
self.addAction(self.action_Level)
self.addAction(self.action_Todo)
self.addAction(self.action_Options)
self.addAction(self.action_Style)
self.addSeparator()
self.addAction(self.action_Help)
self.addAction(self.action_Full)
self.addSeparator()
self.addActions(self.modeGroup.actions())
if(config.mode() == 0):
self.action_Squirrel.setChecked(True)
elif(config.mode() == 1):
self.action_Emo.setChecked(True)
elif(config.mode() == 2):
self.action_And.setChecked(True)
elif(config.mode() == 3):
self.action_Ios.setChecked(True)
def setIcon(self,val):
config.setIconSize(val)
self.setIconSize(QSize(val,val))
def setToolLabel(self):
if (config.toolLabel()):
self.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.setIconSize(QSize(24,24))
else:
self.setIconSize(QSize(16,16))
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
'''Important for multiple callbacks in for loop'''
def make_callback(self, param):
return lambda:self.parent.setFontName(param)
class PreviewWindow(QMainWindow):
"""
QMainWindow subclass used to show frames & tracking.
"""
def __init__(self, controller):
QMainWindow.__init__(self)
# set controller
self.controller = controller
# set title
self.setWindowTitle("Preview")
# get parameter window position & size
param_window_x = self.controller.param_window.x()
param_window_y = self.controller.param_window.y()
param_window_width = self.controller.param_window.width()
# set position & size to be next to the parameter window
self.setGeometry(param_window_x + param_window_width, param_window_y,
10, 10)
# create main widget
self.main_widget = QWidget(self)
self.main_widget.setMinimumSize(QSize(500, 500))
# create main layout
self.main_layout = QGridLayout(self.main_widget)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.main_layout.setSpacing(0)
# create label that shows frames
self.image_widget = QWidget(self)
self.image_layout = QVBoxLayout(self.image_widget)
self.image_layout.setContentsMargins(0, 0, 0, 0)
self.image_label = PreviewQLabel(self)
self.image_label.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.image_label.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.image_label.hide()
self.image_layout.addWidget(self.image_label)
self.main_layout.addWidget(self.image_widget, 0, 0)
# self.image_label.setStyleSheet("border: 1px solid rgba(122, 127, 130, 0.5)")
self.bottom_widget = QWidget(self)
self.bottom_layout = QVBoxLayout(self.bottom_widget)
self.bottom_layout.setContentsMargins(8, 0, 8, 8)
self.bottom_widget.setMaximumHeight(40)
self.main_layout.addWidget(self.bottom_widget, 1, 0)
# create label that shows crop instructions
self.instructions_label = QLabel("")
self.instructions_label.setStyleSheet("font-size: 11px;")
self.instructions_label.setAlignment(Qt.AlignCenter)
self.bottom_layout.addWidget(self.instructions_label)
# create image slider
self.image_slider = QSlider(Qt.Horizontal)
self.image_slider.setFocusPolicy(Qt.StrongFocus)
self.image_slider.setTickPosition(QSlider.NoTicks)
self.image_slider.setTickInterval(1)
self.image_slider.setSingleStep(1)
self.image_slider.setValue(0)
self.image_slider.valueChanged.connect(self.controller.show_frame)
self.image_slider.hide()
self.bottom_layout.addWidget(self.image_slider)
self.zoom = 1
self.offset = [0, 0]
self.center_y = 0
self.center_x = 0
# initialize variables
self.image = None # image to show
self.tracking_data = None # list of tracking data
self.selecting_crop = False # whether user is selecting a crop
self.changing_heading_angle = False # whether the user is changing the heading angle
self.body_crop = None
self.final_image = None
# set main widget
self.setCentralWidget(self.main_widget)
# set window buttons
if pyqt_version == 5:
self.setWindowFlags(Qt.CustomizeWindowHint
| Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowFullscreenButtonHint)
else:
self.setWindowFlags(Qt.CustomizeWindowHint
| Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint)
self.show()
def wheelEvent(self, event):
old_zoom = self.zoom
self.zoom = max(1, self.zoom + event.pixelDelta().y() / 100)
self.zoom = int(self.zoom * 100) / 100.0
self.update_image_label(self.final_image, zooming=True)
def start_selecting_crop(self):
# start selecting crop
self.selecting_crop = True
# add instruction text
self.instructions_label.setText("Click & drag to select crop area.")
def plot_image(self,
image,
params,
crop_params,
tracking_results,
new_load=False,
new_frame=False,
show_slider=True,
crop_around_body=False):
if image is None:
self.update_image_label(None)
self.image_slider.hide()
self.image_label.hide()
else:
if new_load:
self.image_label.show()
self.remove_tail_start()
if show_slider:
if not self.image_slider.isVisible():
self.image_slider.setValue(0)
self.image_slider.setMaximum(self.controller.n_frames -
1)
self.image_slider.show()
else:
self.image_slider.hide()
max_inititial_size = 500
if image.shape[0] > max_inititial_size:
min_height = max_inititial_size
min_width = max_inititial_size * image.shape[
1] / image.shape[0]
elif image.shape[1] > max_inititial_size:
min_width = max_inititial_size
min_height = max_inititial_size * image.shape[
0] / image.shape[1]
else:
min_height = image.shape[0]
min_width = image.shape[1]
self.main_widget.setMinimumSize(
QSize(min_width, min_height + self.bottom_widget.height()))
# convert to RGB
if len(image.shape) == 2:
image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
# update image
self.image = image.copy()
try:
body_crop = params['body_crop']
except:
body_crop = None
try:
tail_start_coords = params['tail_start_coords']
# add tail start point to image
cv2.circle(image, (int(
round(tail_start_coords[1] - crop_params['offset'][1])),
int(
round(tail_start_coords[0] -
crop_params['offset'][0]))), 1,
(180, 180, 50), -1)
except (KeyError, TypeError) as error:
tail_start_coords = None
if tracking_results is not None:
body_position = tracking_results['body_position']
heading_angle = tracking_results['heading_angle']
# add tracking to image
image = tracking.add_tracking_to_frame(image,
tracking_results,
cropped=True)
if body_crop is not None and body_position is not None:
if not crop_around_body:
# copy image
overlay = image.copy()
# draw tail crop overlay
cv2.rectangle(overlay,
(int(body_position[1] - body_crop[1]),
int(body_position[0] - body_crop[0])),
(int(body_position[1] + body_crop[1]),
int(body_position[0] + body_crop[0])),
(242, 242, 65), -1)
# overlay with the original image
cv2.addWeighted(overlay, 0.2, image, 0.8, 0, image)
self.body_crop = None
else:
self.body_crop = body_crop
if crop_around_body:
_, image = tracking.crop_frame_around_body(
image, body_position, params['body_crop'])
self.final_image = image
# update image label
self.update_image_label(
self.final_image,
zoom=(not (crop_around_body and body_position is not None)),
new_load=new_load)
def draw_crop_selection(self, start_crop_coords, end_crop_coords):
if self.selecting_crop and self.image is not None:
# convert image to rgb
if len(self.image.shape) < 3:
image = np.repeat(self.image[:, :, np.newaxis], 3, axis=2)
else:
image = self.image.copy()
# copy image
overlay = image.copy()
# draw crop selection overlay
cv2.rectangle(overlay,
(start_crop_coords[1], start_crop_coords[0]),
(end_crop_coords[1], end_crop_coords[0]),
(255, 51, 0), -1)
# overlay with the original image
cv2.addWeighted(overlay, 0.5, image, 0.5, 0, image)
# update image label
self.update_image_label(image)
def change_offset(self, prev_coords, new_coords):
self.offset[0] -= new_coords[0] - prev_coords[0]
self.offset[1] -= new_coords[1] - prev_coords[1]
self.update_image_label(self.final_image)
def draw_tail_start(self, rel_tail_start_coords):
if self.controller.params['type'] == "headfixed":
# send new tail start coordinates to controller
self.controller.update_tail_start_coords(rel_tail_start_coords)
# clear instructions text
self.instructions_label.setText("")
if self.image is not None:
image = self.image.copy()
cv2.circle(image, (int(round(rel_tail_start_coords[1])),
int(round(rel_tail_start_coords[0]))), 1,
(180, 180, 50), -1)
# update image label
self.update_image_label(image)
def remove_tail_start(self):
self.update_image_label(self.image)
def add_angle_overlay(self, angle):
image = self.image.copy()
image_height = self.image.shape[0]
image_width = self.image.shape[1]
center_y = image_height / 2
center_x = image_width / 2
cv2.arrowedLine(
image,
(int(center_x -
0.3 * image_height * np.sin((angle + 90) * np.pi / 180)),
int(center_y -
0.3 * image_width * np.cos((angle + 90) * np.pi / 180))),
(int(center_x +
0.3 * image_height * np.sin((angle + 90) * np.pi / 180)),
int(center_y +
0.3 * image_width * np.cos((angle + 90) * np.pi / 180))),
(50, 255, 50), 2)
self.update_image_label(image)
def remove_angle_overlay(self):
self.update_image_label(self.image)
def update_image_label(self,
image,
zoom=True,
new_load=False,
zooming=False):
if image is not None and self.zoom != 1 and zoom:
if zooming:
self.offset[0] = min(
max(
0, self.offset[0] + int(
(self.image_label.image.shape[0]) / 2.0) -
int(round((image.shape[0] / self.zoom) / 2.0))),
image.shape[0] - int(round(image.shape[0] / self.zoom)))
self.offset[1] = min(
max(
0, self.offset[1] + int(
(self.image_label.image.shape[1]) / 2.0) -
int(round((image.shape[1] / self.zoom) / 2.0))),
image.shape[1] - int(round(image.shape[1] / self.zoom)))
else:
self.offset[0] = min(
max(0, self.offset[0]),
image.shape[0] - int(round(image.shape[0] / self.zoom)))
self.offset[1] = min(
max(0, self.offset[1]),
image.shape[1] - int(round(image.shape[1] / self.zoom)))
if self.center_y is None:
self.center_y = int(round(image.shape[0] / 2.0))
if self.center_x is None:
self.center_x = int(round(image.shape[1] / 2.0))
image = image[
self.offset[0]:int(round(image.shape[0] / self.zoom)) +
self.offset[0],
self.offset[1]:int(round(image.shape[1] / self.zoom)) +
self.offset[1], :].copy()
if image is not None:
if zoom:
self.setWindowTitle("Preview - Zoom: {:.1f}x".format(
self.zoom))
else:
self.setWindowTitle("Preview - Zoom: 1x")
else:
self.setWindowTitle("Preview")
self.image_label.update_pixmap(image, new_load=new_load)
def crop_selection(self, start_crop_coord, end_crop_coord):
if self.selecting_crop:
# stop selecting the crop
self.selecting_crop = False
# clear instruction text
self.instructions_label.setText("")
# update crop parameters from the selection
self.controller.update_crop_from_selection(start_crop_coord,
end_crop_coord)
def closeEvent(self, ce):
if not self.controller.closing:
ce.ignore()
else:
ce.accept()
class Tool(QToolBar):
def __init__(self,parent):
QToolBar.__init__(self,parent)
self.parent = parent
self.action_NewProject = QAction(Icons.newprj, 'Project', self)
self.action_NewProject.triggered.connect(self.parent.treeWidget.newProject)
self.action_NewProject.setToolTip("Create a New Project")
self.action_Open = QAction(Icons.open, 'Open', self)
self.action_Open.triggered.connect(self.parent.fileOpen)
self.action_Open.setToolTip("Open File")
self.action_Save = QAction(Icons.save, 'Save', self)
self.action_Save.setShortcut('Ctrl+S')
self.action_Save.triggered.connect(self.parent.fileSave)
self.action_Save.setToolTip("Save Current File")
self.action_SaveAll = QAction(Icons.saveall, 'SaveAll', self)
self.action_SaveAll.setShortcut('Ctrl+A')
self.action_SaveAll.triggered.connect(self.parent.fileSaveAll)
self.action_SaveAll.setToolTip("Save All Files")
self.action_Build = QAction(Icons.thread_view, 'Build', self)
self.action_Build.setShortcut('Ctrl+B')
self.action_Build.triggered.connect(self.parent.build_project)
self.action_Debug = QAction(Icons.debug_exec, 'Debug', self)
self.action_Refresh = QAction(Icons.refresh_tab, 'Refresh', self)
self.action_Refresh.triggered.connect(self.parent.treeWidget.refreshCurrentProject)
self.action_Run = QAction(Icons.run, 'Run', self)
self.action_Run.setShortcut('Ctrl+R')
self.action_Run.triggered.connect(self.parent.adb.run)
self.action_RunFile = QAction(Icons.go, 'Cmd', self)
self.action_RunFile.triggered.connect(self.parent.openCommand)
self.parent.runButton.clicked.connect(self.parent.command.setCmdLine)
self.action_Stop = QAction(Icons.stop, 'Stop', self)
self.action_Stop.setShortcut('Ctrl+Q')
self.action_Stop.triggered.connect(self.parent.adb.stop)
self.action_Design = QAction(Icons.color_palette, 'Design', self)
self.action_Design.triggered.connect(self.parent.design)
self.action_Level = QAction(Icons.cmpC_pal, 'Level', self)
self.action_Level.triggered.connect(self.parent.level)
self.action_Todo = QAction(Icons.task_set, 'Todo', self)
self.action_Todo.triggered.connect(self.parent.todo)
self.action_Help = QAction(Icons.toc_open, 'Help', self)
self.action_Help.triggered.connect(self.parent.help)
self.action_Full = QAction(Icons.fullscreen, 'Full', self)
self.action_Full.triggered.connect(self.parent.full)
self.action_Stop.setDisabled(True)
self.setToolLabel()
self.setAllowedAreas(Qt.AllToolBarAreas)
#self.setFixedHeight(40)
#self.setIconSize(QSize(config.iconSize(),config.iconSize()))
''' Adding all Actions '''
self.addAction(self.action_NewProject)
self.addAction(self.action_Open)
self.addAction(self.action_Save)
self.addAction(self.action_SaveAll)
#self.addAction(self.action_Refresh)
self.addSeparator()
self.addAction(self.action_Build)
self.addAction(self.action_Run)
#self.addAction(self.action_RunFile)
self.addAction(self.action_Stop)
self.addAction(self.action_Debug)
self.addSeparator()
self.addAction(self.action_Design)
self.addAction(self.action_Level)
self.addAction(self.action_Todo)
self.initOptionsMenu()
self.addSeparator()
self.initStyleMenu()
self.initLexerMenu()
self.initApiMenu()
#self.addAction(self.action_Help)
#self.addAction(self.action_Full)
self.addSeparator()
self.initModeMenu()
def colorChange(self, text, color):
#print "colorChange ",text,color
editStyle = config.readStyle()
editStyle[text] = color
config.writeStyle(editStyle)
for i in range(len(self.parent.files)):
self.parent.tabWidget.widget(i).setEditorStyle()
def setColors(self,action):
print action.text()
def changeAll(self):
self.colorChange("base", "#ffffff")
def setIcon(self,val):
config.setIconSize(val)
self.setIconSize(QSize(val,val))
def setToolLabel(self):
if (config.toolLabel()):
self.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.setIconSize(QSize(24,24))
else:
self.setIconSize(QSize(16,16))
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
'''Important for multiple callbacks in for loop'''
def make_callback(self, text):
return lambda:self.colorChange(text)
''' Options Menu '''
def initOptionsMenu(self):
men = QMenu()
#Threshold Slider
self.threshSlider = QSlider()
self.threshSlider.setTickPosition(QSlider.TicksLeft)
self.threshSlider.setOrientation(Qt.Horizontal)
self.threshSlider.setValue(config.thresh())
self.threshSlider.setMinimum(0)
self.threshSlider.setMaximum(5)
self.threshSlider.valueChanged.connect(self.parent.setThreshold)
self.threshSliderAction = QWidgetAction(men)
self.threshSliderAction.setDefaultWidget(self.threshSlider)
#TabsWidth Slider
self.tabsSlider = QSlider()
self.tabsSlider.setTickPosition(QSlider.TicksLeft)
self.tabsSlider.setOrientation(Qt.Horizontal)
self.tabsSlider.setValue(config.tabwidth())
self.tabsSlider.setMinimum(0)
self.tabsSlider.setMaximum(8)
self.tabsSlider.valueChanged.connect(self.parent.setTabWidth)
self.tabsSliderAction = QWidgetAction(men)
self.tabsSliderAction.setDefaultWidget(self.tabsSlider)
#iconSize Slider
self.iconSlider = QSlider()
self.iconSlider.setTickPosition(QSlider.TicksLeft)
self.iconSlider.setOrientation(Qt.Horizontal)
self.iconSlider.setValue(config.iconSize())
self.iconSlider.setMinimum(16)
self.iconSlider.setMaximum(32)
self.iconSlider.setSingleStep(2)
self.iconSlider.valueChanged.connect(self.setIcon)
self.iconSliderAction = QWidgetAction(men)
self.iconSliderAction.setDefaultWidget(self.iconSlider)
'''Font Button'''
self.fontCombo = QFontComboBox()
self.fontCombo.currentFontChanged.connect(self.parent.setFont)
self.fontCombo.setCurrentFont(QFont(config.fontName()))
self.fontComboMenu = QWidgetAction(men)
self.fontComboMenu.setDefaultWidget(self.fontCombo)
'''Font Size'''
self.fontSizeCombo = QComboBox()
for size in range(1,40):
self.fontSizeCombo.addItem(str(size))
self.fontSizeCombo.setCurrentIndex(config.fontSize())
self.fontSizeCombo.currentIndexChanged.connect(self.parent.setFontSize)
self.fontSizeComboMenu = QWidgetAction(men)
self.fontSizeComboMenu.setDefaultWidget(self.fontSizeCombo)
action_Android = QAction(Icons.android,'Android', self)
action_Android.triggered.connect(self.parent.android)
action_Ant = QAction(Icons.ant_view,'Ant', self)
action_Ant.triggered.connect(self.parent.antt)
action_Squirrel = QAction(Icons.nut,'Squirrel', self)
action_Squirrel.triggered.connect(self.parent.squirrel)
action_Ios1 = QAction(Icons.ios,'iOS', self)
action_Update = QAction(Icons.update,"Update",self)
action_Update.triggered.connect(self.parent.update)
action_explorer = QAction("Explorer",self)
action_explorer.triggered.connect(self.parent.exp)
action_explorer.setCheckable(True)
action_explorer.setChecked(True)
action_console = QAction("Console",self)
action_console.triggered.connect(self.parent.cmd)
action_console.setCheckable(True)
action_console.setChecked(False)
#action_designer = QAction("Designer",self)
#action_designer.triggered.connect(self.parent.design)
action_Indentation = QAction("Indentation Guides",self)
action_Indentation.triggered.connect(self.parent.setIndent)
action_Indentation.setCheckable(True)
action_Indentation.setChecked(config.indent())
action_WhiteSpace = QAction("WhiteSpace",self)
action_WhiteSpace.triggered.connect(self.parent.setWhiteSpace)
action_WhiteSpace.setCheckable(True)
action_WhiteSpace.setChecked(config.whiteSpace())
action_EndLine = QAction("End of Lines",self)
action_EndLine.triggered.connect(self.parent.setEndLine)
action_EndLine.setCheckable(True)
action_Margin = QAction("Line Numbers",self)
action_Margin.triggered.connect(self.parent.setMargin)
action_Margin.setCheckable(True)
action_Margin.setChecked(config.margin())
action_ToolLabel = QAction("Tool Labels",self)
action_ToolLabel.triggered.connect(self.setToolLabel)
action_ToolLabel.setCheckable(True)
#action_ToolLabel.setChecked(config.toolLabel())
'''Encoding'''
encodingGroup = QActionGroup(self)
encodingGroup.setExclusive(True)
action_Ascii = QAction("Ascii",encodingGroup)
action_Ascii.setCheckable(True)
action_Unicode = QAction("Unicode",encodingGroup)
action_Unicode.setCheckable(False)
encodingGroup.addAction(action_Ascii)
encodingGroup.addAction(action_Unicode)
encodingGroup.selected.connect(self.parent.setEncoding)
if(config.encoding() == Encoding.ASCII):
action_Ascii.setChecked(True)
else:
action_Unicode.setChecked(True)
men.addAction(action_Update)
men.addAction(self.action_Help)
men.addAction(self.action_Full)
men.addSeparator()
men.addAction(action_Android)
men.addAction(action_Ant)
men.addAction(action_Squirrel)
men.addAction(action_Ios1)
men.addSeparator()
men.addAction(action_explorer)
men.addAction(action_console)
#men.addAction(action_designer)
men.addSeparator()
men.addAction(action_Indentation)
men.addAction(action_WhiteSpace)
men.addAction(action_EndLine)
men.addAction(action_Margin)
men.addAction(action_ToolLabel)
men.addSeparator()
men.addActions(encodingGroup.actions())
men.addSeparator()
head_font = QLabel("Font---------------------")
fnt = head_font.font()
fnt.setBold(True)
head_font.setFont(fnt)
head_fontWidgetAction = QWidgetAction(men)
head_fontWidgetAction.setDefaultWidget(head_font)
men.addAction(head_fontWidgetAction)
men.addAction(self.fontComboMenu)
men.addAction(self.fontSizeComboMenu)
men.addSeparator()
men.addAction(QAction("TabWidth",self))
men.addAction(self.tabsSliderAction)
men.addSeparator()
men.addAction(QAction("Threshold",self))
men.addAction(self.threshSliderAction)
#men.addAction(QAction("Icon Size",self))
#men.addAction(self.iconSliderAction)
self.action_Options = QAction(Icons.emblem_system, 'Options', self)
self.action_Options.setMenu(men)
self.addAction(self.action_Options)
''' Mode Menu '''
def initModeMenu(self):
self.modeGroup = QActionGroup(self)
self.modeGroup.setExclusive(True)
self.modeGroup.selected.connect(self.parent.setMode)
self.action_Squirrel = QAction(Icons.nut, 'Squ', self.modeGroup)
self.action_Squirrel.setCheckable(True)
self.action_Emo = QAction(Icons.emo, 'Emo', self.modeGroup)
self.action_Emo.setCheckable(True)
self.action_And = QAction(Icons.android, 'Android', self.modeGroup)
self.action_And.setCheckable(True)
self.action_Ios = QAction(Icons.ios, 'ios', self.modeGroup)
self.action_Ios.setCheckable(True)
self.modeGroup.addAction(self.action_Squirrel)
self.modeGroup.addAction(self.action_Emo)
self.modeGroup.addAction(self.action_And)
self.modeGroup.addAction(self.action_Ios)
self.addActions(self.modeGroup.actions())
if(config.mode() == 0):
self.action_Squirrel.setChecked(True)
self.action_Build.setEnabled(False)
self.action_Run.setEnabled(False)
elif(config.mode() == 1):
self.action_Emo.setChecked(True)
self.action_Build.setEnabled(True)
self.action_Run.setEnabled(True)
elif(config.mode() == 2):
self.action_And.setChecked(True)
self.action_Build.setEnabled(True)
self.action_Run.setEnabled(True)
elif(config.mode() == 3):
self.action_Ios.setChecked(True)
self.action_Build.setEnabled(False)
self.action_Run.setEnabled(False)
''' Style Menu '''
def initStyleMenu(self):
editStyle = config.readStyle()
self.action_Style = QAction(Icons.style, 'Style', self)
men = QMenu(self)
men1 = QMenu()
self.base = StyleWidget(self,"base",editStyle["base"])
self.back = StyleWidget(self,"back",editStyle["back"])
self.caret = StyleWidget(self,"caret",editStyle["caret"])
self.margin = StyleWidget(self,"margin",editStyle["margin"])
self.marker = StyleWidget(self,"marker",editStyle["marker"])
self.comment = StyleWidget(self,"comment",editStyle["comment"])
self.number = StyleWidget(self,"number",editStyle["number"])
self.keyword = StyleWidget(self,"keyword",editStyle["keyword"])
self.string = StyleWidget(self,"string",editStyle["string"])
self.operator = StyleWidget(self,"operator",editStyle["operator"])
self.connect(self.base, SIGNAL("colorChange"),self.colorChange)
self.connect(self.back, SIGNAL("colorChange"),self.colorChange)
self.connect(self.caret, SIGNAL("colorChange"),self.colorChange)
self.connect(self.margin, SIGNAL("colorChange"),self.colorChange)
self.connect(self.marker, SIGNAL("colorChange"),self.colorChange)
self.connect(self.comment, SIGNAL("colorChange"),self.colorChange)
self.connect(self.number, SIGNAL("colorChange"),self.colorChange)
self.connect(self.keyword, SIGNAL("colorChange"),self.colorChange)
self.connect(self.string, SIGNAL("colorChange"),self.colorChange)
self.connect(self.operator, SIGNAL("colorChange"),self.colorChange)
self.baseMenu = QWidgetAction(men)
self.baseMenu.setDefaultWidget(self.base)
self.backMenu = QWidgetAction(men)
self.backMenu.setDefaultWidget(self.back)
self.caretMenu = QWidgetAction(men)
self.caretMenu.setDefaultWidget(self.caret)
self.marginMenu = QWidgetAction(men)
self.marginMenu.setDefaultWidget(self.margin)
self.markerMenu = QWidgetAction(men)
self.markerMenu.setDefaultWidget(self.marker)
self.commentMenu = QWidgetAction(men)
self.commentMenu.setDefaultWidget(self.comment)
self.numberMenu = QWidgetAction(men)
self.numberMenu.setDefaultWidget(self.number)
self.keywordMenu = QWidgetAction(men)
self.keywordMenu.setDefaultWidget(self.keyword)
self.stringMenu = QWidgetAction(men)
self.stringMenu.setDefaultWidget(self.string)
self.operatorMenu = QWidgetAction(men)
self.operatorMenu.setDefaultWidget(self.operator)
self.styleGroup = QActionGroup(self)
self.styleGroup.setExclusive(True)
self.styleGroup.selected.connect(self.setColors)
self.style1 = QAction("All Hallow's Eve",self.styleGroup)
self.style1.setCheckable(True)
self.style2 = QAction("Amy",self.styleGroup)
self.style2.setCheckable(True)
self.style3 = QAction("Aptana Studio",self.styleGroup)
self.style3.setCheckable(True)
self.style4 = QAction("Bespin",self.styleGroup)
self.style4.setCheckable(True)
self.style5 = QAction("Blackboard",self.styleGroup)
self.style5.setCheckable(True)
self.style6 = QAction("Choco",self.styleGroup)
self.style6.setCheckable(True)
self.style7 = QAction("Cobalt",self.styleGroup)
self.style7.setCheckable(True)
self.style8 = QAction("Dawn",self.styleGroup)
self.style8.setCheckable(True)
self.style9 = QAction("Eclipse",self.styleGroup)
self.style9.setCheckable(True)
self.styleGroup.addAction(self.style1)
self.styleGroup.addAction(self.style2)
self.styleGroup.addAction(self.style3)
self.styleGroup.addAction(self.style4)
self.styleGroup.addAction(self.style5)
self.styleGroup.addAction(self.style6)
self.styleGroup.addAction(self.style7)
self.styleGroup.addAction(self.style8)
self.styleGroup.addAction(self.style9)
men1.addAction(self.baseMenu)
men1.addAction(self.backMenu)
men1.addAction(self.caretMenu)
men1.addAction(self.marginMenu)
men1.addAction(self.markerMenu)
men1.addAction(self.commentMenu)
men1.addAction(self.numberMenu)
men1.addAction(self.keywordMenu)
men1.addAction(self.stringMenu)
men1.addAction(self.operatorMenu)
men1.addSeparator()
men2 = QMenu(self)
men2.setTitle("Styles")
men2.addActions(self.styleGroup.actions())
men1.addMenu(men2)
self.action_Style.setMenu(men1)
self.addAction(self.action_Style)
''' Lexer Menu'''
def make_action_lex(self, text):
action = QAction(text, self.lexGroup)
action.setCheckable(True)
return action
def initLexerMenu(self):
self.action_Lexer = QAction(Icons.file_obj, 'Lexer', self)
men = QMenu()
self.lexGroup = QActionGroup(self)
self.lexGroup.setExclusive(True)
self.lexGroup.selected.connect(self.parent.setLexer)
#langs = [i for i in dir(Qsci) if i.startswith('QsciLexer')]
langs = ['Bash', 'Batch', 'CMake', 'CPP', 'CSS', 'C#','HTML','Java', 'JavaScript', 'Lua', 'Makefile','Python', 'SQL', 'XML', 'YAML']
for l in langs:
act = self.make_action_lex(l)
self.lexGroup.addAction(act)
if(langs.index(l) == 8): #For javascript
act.setChecked(True)
#print l[9:] # we don't need to print "QsciLexer" before each name
men.addActions(self.lexGroup.actions())
self.action_Lexer.setMenu(men)
self.addAction(self.action_Lexer)
''' Api Menu '''
def make_action_api(self, text):
action = QAction(text, self.apiGroup)
action.setCheckable(True)
return action
def initApiMenu(self):
self.action_Api = QAction(Icons.lib, 'Api', self)
men = QMenu()
self.apiGroup = QActionGroup(self)
self.apiGroup.setExclusive(True)
self.apiGroup.selected.connect(self.parent.setApi)
list = oslistdir(apiDir)
apis = []
if(list != None):
for i in list:
if i.endswith("api"):
apis.append(i.replace(".api", ""))
if(apis != None):
for i in apis:
act = self.make_action_api(i)
self.apiGroup.addAction(act)
if(i == "emo"): #For emo
act.setChecked(True)
men.addActions(self.apiGroup.actions())
self.action_Api.setMenu(men)
self.addAction(self.action_Api)
class MyMainWindow(QMainWindow):
' Main Window '
def __init__(self, AUTO):
' Initialize QWidget inside MyMainWindow '
super(MyMainWindow, self).__init__()
QWidget.__init__(self)
self.auto = AUTO
self.statusBar().showMessage(' {}'.format(__doc__))
self.setStyleSheet('QStatusBar{color:grey;}')
self.setWindowTitle(__doc__)
self.setWindowIcon(QIcon.fromTheme("face-monkey"))
self.setFont(QFont('Ubuntu Light', 10))
self.setMaximumSize(QDesktopWidget().screenGeometry().width(),
QDesktopWidget().screenGeometry().height())
self.base = path.abspath(path.join(getcwd(), str(datetime.now().year)))
# directory auto completer
self.completer = QCompleter(self)
self.dirs = QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
# process
self.process1 = None
self.process2 = None
self.cmd1 = 'nice -n {n} arecord{v} -f {f} -c {c} -r {b} -t raw'
self.cmd2 = 'oggenc - -r -C {c} -R {b} -q {q} {d}{t}{a} -o {o}'
self.process3 = QProcess(self)
#self.process3.finished.connect(self.on_process3_finished)
#self.process3.error.connect(self.on_process3_error)
self.cmd3 = ('nice -n 20 ' +
'sox "{o}" -n spectrogram -x {x} -y {y} -z 99 -t "{o}" -o "{o}.png"')
self.actual_file = ''
# re starting timers, one stops, one starts
self.timerFirst = QTimer(self)
self.timerFirst.timeout.connect(self.end)
self.timerSecond = QTimer(self)
self.timerSecond.timeout.connect(self.run)
# Proxy support, by reading http_proxy os env variable
proxy_url = QUrl(environ.get('http_proxy', ''))
QNetworkProxy.setApplicationProxy(QNetworkProxy(QNetworkProxy.HttpProxy
if str(proxy_url.scheme()).startswith('http')
else QNetworkProxy.Socks5Proxy, proxy_url.host(), proxy_url.port(),
proxy_url.userName(), proxy_url.password())) \
if 'http_proxy' in environ else None
print((' INFO: Proxy Auto-Config as ' + str(proxy_url)))
# basic widgets layouts and set up
self.mainwidget = QTabWidget()
self.mainwidget.setToolTip(__doc__)
self.mainwidget.setMovable(True)
self.mainwidget.setTabShape(QTabWidget.Triangular)
self.mainwidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.mainwidget.setStyleSheet('QTabBar{color:white;font-weight:bold;}')
self.mainwidget.setTabBar(TabBar(self))
self.mainwidget.setTabsClosable(False)
self.setCentralWidget(self.mainwidget)
self.dock1 = QDockWidget()
self.dock2 = QDockWidget()
self.dock3 = QDockWidget()
self.dock4 = QDockWidget()
self.dock5 = QDockWidget()
for a in (self.dock1, self.dock2, self.dock3, self.dock4, self.dock5):
a.setWindowModality(Qt.NonModal)
# a.setWindowOpacity(0.9)
a.setWindowTitle(__doc__
if a.windowTitle() == '' else a.windowTitle())
a.setStyleSheet('QDockWidget::title{text-align:center;}')
self.mainwidget.addTab(a, QIcon.fromTheme("face-smile"),
'Double Click Me')
# Paleta de colores para pintar transparente
self.palette().setBrush(QPalette.Base, Qt.transparent)
self.setPalette(self.palette())
self.setAttribute(Qt.WA_OpaquePaintEvent, False)
# toolbar and basic actions
self.toolbar = QToolBar(self)
self.toolbar.setIconSize(QSize(24, 24))
# spacer widget for left
self.left_spacer = QWidget(self)
self.left_spacer.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
# spacer widget for right
self.right_spacer = QWidget(self)
self.right_spacer.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
qaqq = QAction(QIcon.fromTheme("application-exit"), 'Quit', self)
qaqq.setShortcut('Ctrl+Q')
qaqq.triggered.connect(exit)
qamin = QAction(QIcon.fromTheme("go-down"), 'Minimize', self)
qamin.triggered.connect(lambda: self.showMinimized())
qamax = QAction(QIcon.fromTheme("go-up"), 'Maximize', self)
qanor = QAction(QIcon.fromTheme("view-fullscreen"),
'AutoCenter AutoResize', self)
qanor.triggered.connect(self.center)
qatim = QAction(QIcon.fromTheme("mail-signed-verified"),
'View Date and Time', self)
qatim.triggered.connect(self.timedate)
qabug = QAction(QIcon.fromTheme("help-about"), 'Report a Problem', self)
qabug.triggered.connect(lambda: qabug.setDisabled(True) if not call(
'xdg-open mailto:' + '*****@*****.**'.decode('rot13'),
shell=True) else ' ERROR ')
qamax.triggered.connect(lambda: self.showMaximized())
qaqt = QAction(QIcon.fromTheme("help-about"), 'About Qt', self)
qaqt.triggered.connect(lambda: QMessageBox.aboutQt(self))
qakde = QAction(QIcon.fromTheme("help-about"), 'About KDE', self)
if KDE:
qakde.triggered.connect(KHelpMenu(self, "", False).aboutKDE)
qaslf = QAction(QIcon.fromTheme("help-about"), 'About Self', self)
if KDE:
qaslf.triggered.connect(
KAboutApplicationDialog(aboutData, self).exec_)
else:
qaslf.triggered.connect(lambda: QMessageBox.about(self.mainwidget,
__doc__, ''.join((__doc__, linesep, 'version ', __version__, ', (',
__license__, '), by ', __author__, ', ( ', __email__, ' )', linesep
))))
qafnt = QAction(QIcon.fromTheme("tools-check-spelling"),
'Set GUI Font', self)
if KDE:
font = QFont()
qafnt.triggered.connect(lambda:
self.setStyleSheet(''.join((
'*{font-family:', str(font.toString()), '}'))
if KFontDialog.getFont(font)[0] == QDialog.Accepted else ''))
else:
qafnt.triggered.connect(lambda:
self.setStyleSheet(''.join(('*{font-family:',
str(QFontDialog.getFont()[0].toString()), '}'))))
qasrc = QAction(QIcon.fromTheme("applications-development"),
'View Source Code', self)
qasrc.triggered.connect(lambda:
call('xdg-open {}'.format(__file__), shell=True))
qakb = QAction(QIcon.fromTheme("input-keyboard"),
'Keyboard Shortcuts', self)
qakb.triggered.connect(lambda: QMessageBox.information(self.mainwidget,
'Keyboard Shortcuts', ' Ctrl+Q = Quit '))
qapic = QAction(QIcon.fromTheme("camera-photo"),
'Take a Screenshot', self)
qapic.triggered.connect(lambda: QPixmap.grabWindow(
QApplication.desktop().winId()).save(QFileDialog.getSaveFileName(
self.mainwidget, " Save Screenshot As ...", path.expanduser("~"),
';;(*.png) PNG', 'png')))
qatb = QAction(QIcon.fromTheme("go-top"), 'Toggle ToolBar', self)
qatb.triggered.connect(lambda: self.toolbar.hide()
if self.toolbar.isVisible() is True else self.toolbar.show())
qati = QAction(QIcon.fromTheme("zoom-in"),
'Switch ToolBar Icon Size', self)
qati.triggered.connect(lambda:
self.toolbar.setIconSize(self.toolbar.iconSize() * 4)
if self.toolbar.iconSize().width() * 4 == 24
else self.toolbar.setIconSize(self.toolbar.iconSize() / 4))
qasb = QAction(QIcon.fromTheme("preferences-other"),
'Toggle Tabs Bar', self)
qasb.triggered.connect(lambda: self.mainwidget.tabBar().hide()
if self.mainwidget.tabBar().isVisible() is True
else self.mainwidget.tabBar().show())
qadoc = QAction(QIcon.fromTheme("help-browser"), 'On-line Docs', self)
qadoc.triggered.connect(lambda: open_new_tab(str(__url__).strip()))
qapy = QAction(QIcon.fromTheme("help-about"), 'About Python', self)
qapy.triggered.connect(lambda: open_new_tab('http://python.org/about'))
qali = QAction(QIcon.fromTheme("help-browser"), 'Read Licence', self)
qali.triggered.connect(lambda: open_new_tab(__full_licence__))
qacol = QAction(QIcon.fromTheme("preferences-system"), 'Set GUI Colors',
self)
if KDE:
color = QColor()
qacol.triggered.connect(lambda:
self.setStyleSheet(''.join(('* { background-color: ',
str(color.name()), '}')))
if KColorDialog.getColor(color, self) else '')
else:
qacol.triggered.connect(lambda: self.setStyleSheet(''.join((
' * { background-color: ', str(QColorDialog.getColor().name()),
' } '))))
qatit = QAction(QIcon.fromTheme("preferences-system"),
'Set the App Window Title', self)
qatit.triggered.connect(self.seTitle)
self.toolbar.addWidget(self.left_spacer)
self.toolbar.addSeparator()
self.toolbar.addActions((qaqq, qamin, qanor, qamax, qasrc, qakb, qacol,
qatim, qatb, qafnt, qati, qasb, qatit, qapic, qadoc, qali, qaslf,
qaqt, qakde, qapy, qabug))
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
self.toolbar.addSeparator()
self.toolbar.addWidget(self.right_spacer)
# define the menu
menu = self.menuBar()
# File menu items
menu.addMenu('&File').addActions((qaqq, ))
menu.addMenu('&Window').addActions((qamax, qanor, qamin))
# Settings menu
menu.addMenu('&Settings').addActions((qasrc, qacol, qafnt, qatim,
qatb, qati, qasb, qapic))
# Help menu items
menu.addMenu('&Help').addActions((qadoc, qakb, qabug, qali,
qaqt, qakde, qapy, qaslf))
# Tray Icon
tray = QSystemTrayIcon(QIcon.fromTheme("face-devilish"), self)
tray.setToolTip(__doc__)
traymenu = QMenu()
traymenu.addActions((qamax, qanor, qamin, qaqq))
tray.setContextMenu(traymenu)
tray.show()
def contextMenuRequested(point):
' quick and dirty custom context menu '
menu = QMenu()
menu.addActions((qaqq, qamin, qanor, qamax, qasrc, qakb, qacol,
qafnt, qati, qasb, qatb, qatim, qatit, qapic, qadoc, qali,
qaslf, qaqt, qakde, qapy, qabug))
menu.exec_(self.mapToGlobal(point))
self.mainwidget.customContextMenuRequested.connect(contextMenuRequested)
def must_be_checked(widget_list):
' widget tuple passed as argument should be checked as ON '
for each_widget in widget_list:
try:
each_widget.setChecked(True)
except:
pass
def must_have_tooltip(widget_list):
' widget tuple passed as argument should have tooltips '
for each_widget in widget_list:
try:
each_widget.setToolTip(each_widget.text())
except:
each_widget.setToolTip(each_widget.currentText())
finally:
each_widget.setCursor(QCursor(Qt.PointingHandCursor))
def must_autofillbackground(widget_list):
' widget tuple passed as argument should have filled background '
for each_widget in widget_list:
try:
each_widget.setAutoFillBackground(True)
except:
pass
def must_glow(widget_list):
' apply an glow effect to the widget '
for glow, each_widget in enumerate(widget_list):
try:
if each_widget.graphicsEffect() is None:
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
each_widget.setGraphicsEffect(glow)
# glow.setEnabled(False)
try:
each_widget.clicked.connect(lambda:
each_widget.graphicsEffect().setEnabled(True)
if each_widget.graphicsEffect().isEnabled() is False
else each_widget.graphicsEffect().setEnabled(False))
except:
each_widget.sliderPressed.connect(lambda:
each_widget.graphicsEffect().setEnabled(True)
if each_widget.graphicsEffect().isEnabled() is False
else each_widget.graphicsEffect().setEnabled(False))
except:
pass
#######################################################################
# dock 1
QLabel('<h1 style="color:white;"> Record !</h1>', self.dock1).resize(
self.dock3.size().width() / 4, 25)
self.group1 = QGroupBox()
self.group1.setTitle(__doc__)
self.spec = QPushButton(self)
self.spec.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.spec.setMinimumSize(self.spec.size().width(), 250)
self.spec.setFlat(True)
self.spec.clicked.connect(self.spectro)
self.clock = QLCDNumber()
self.clock.setSegmentStyle(QLCDNumber.Flat)
self.clock.setMinimumSize(self.clock.size().width(), 50)
self.clock.setNumDigits(25)
self.timer1 = QTimer(self)
self.timer1.timeout.connect(lambda: self.clock.display(
datetime.now().strftime("%d-%m-%Y %H:%M:%S %p")))
self.timer1.start(1000)
self.clock.setToolTip(datetime.now().strftime("%c %x"))
self.clock.setCursor(QCursor(Qt.CrossCursor))
self.diskBar = QProgressBar()
self.diskBar.setMinimum(0)
self.diskBar.setMaximum(statvfs(HOME).f_blocks *
statvfs(HOME).f_frsize / 1024 / 1024 / 1024)
self.diskBar.setValue(statvfs(HOME).f_bfree *
statvfs(HOME).f_frsize / 1024 / 1024 / 1024)
self.diskBar.setToolTip(str(statvfs(HOME).f_bfree *
statvfs(HOME).f_frsize / 1024 / 1024 / 1024) + ' Gigabytes free')
self.feedback = QPlainTextEdit(''.join(('<center><h3>', __doc__,
', version', __version__, __license__, ' <br> by ', __author__,
' <i>(Dev)</i>, Radio Comunitaria FM Reconquista <i>(Q.A.)</i><br>',
'FMReconquista.org.ar & GitHub.com/JuanCarlosPaco/Cinta-Testigo')))
self.rec = QPushButton(QIcon.fromTheme("media-record"), 'Record')
self.rec.setMinimumSize(self.rec.size().width(), 50)
self.rec.clicked.connect(self.go) # self.run
self.stop = QPushButton(QIcon.fromTheme("media-playback-stop"), 'Stop')
self.stop.clicked.connect(self.end)
self.kill = QPushButton(QIcon.fromTheme("process-stop"), 'Kill')
self.kill.clicked.connect(self.killer)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (
QLabel('<b style="color:white;"> Spectro'), self.spec,
QLabel('<b style="color:white;"> Time '), self.clock,
QLabel('<b style="color:white;"> Disk '), self.diskBar,
QLabel('<b style="color:white;"> STDOUT + STDIN '), self.feedback,
QLabel('<b style="color:white;"> Record '), self.rec, self.stop,
self.kill):
vboxg1.addWidget(each_widget)
self.group2 = QGroupBox()
self.group2.setTitle(__doc__)
self.slider = QSlider(self)
self.slid_l = QLabel(self.slider)
self.slider.setCursor(QCursor(Qt.OpenHandCursor))
self.slider.sliderPressed.connect(lambda:
self.slider.setCursor(QCursor(Qt.ClosedHandCursor)))
self.slider.sliderReleased.connect(lambda:
self.slider.setCursor(QCursor(Qt.OpenHandCursor)))
self.slider.valueChanged.connect(lambda:
self.slider.setToolTip(str(self.slider.value())))
self.slider.valueChanged.connect(lambda: self.slid_l.setText(
'<h2 style="color:white;">{}'.format(self.slider.value())))
self.slider.setMinimum(10)
self.slider.setMaximum(99)
self.slider.setValue(30)
self.slider.setOrientation(Qt.Vertical)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setTickInterval(2)
self.slider.setSingleStep(10)
self.slider.setPageStep(10)
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (
QLabel('<b style="color:white;">MINUTES of recording'), self.slider,
QLabel('<b style="color:white;"> Default: 30 Min')):
vboxg2.addWidget(each_widget)
group3 = QGroupBox()
group3.setTitle(__doc__)
try:
self.label2 = QLabel(getoutput('sox --version', shell=True))
self.label4 = QLabel(getoutput('arecord --version', shell=1)[:25])
self.label6 = QLabel(str(getoutput('oggenc --version', shell=True)))
except:
print(''' ERROR: No SOX, OGGenc avaliable !
( sudo apt-get install vorbis-tools sox alsa-utils ) ''')
exit()
self.button5 = QPushButton(QIcon.fromTheme("audio-x-generic"),
'OGG --> ZIP')
self.button5.clicked.connect(lambda: make_archive(
str(QFileDialog.getSaveFileName(self, "Save OGG to ZIP file As...",
getcwd(), ';;(*.zip)', 'zip')).replace('.zip', ''), "zip",
path.abspath(path.join(getcwd(), str(datetime.now().year)))))
self.button1 = QPushButton(QIcon.fromTheme("folder-open"), 'Files')
self.button1.clicked.connect(lambda:
call('xdg-open ' + getcwd(), shell=True))
self.button0 = QPushButton(
QIcon.fromTheme("preferences-desktop-screensaver"), 'LCD OFF')
self.button0.clicked.connect(lambda:
call('sleep 3 ; xset dpms force off', shell=True))
vboxg3 = QVBoxLayout(group3)
for each_widget in (
QLabel('<b style="color:white;"> OGG Output Codec '), self.label6,
QLabel('<b style="color:white;"> Raw Record Backend '), self.label4,
QLabel('<b style="color:white;"> Helper Libs '), self.label2,
QLabel('<b style="color:white;"> OGG ZIP '), self.button5,
QLabel('<b style="color:white;"> Files '), self.button1,
QLabel('<b style="color:white;"> LCD '), self.button0):
vboxg3.addWidget(each_widget)
container = QWidget()
hbox = QHBoxLayout(container)
for each_widget in (self.group2, self.group1, group3):
hbox.addWidget(each_widget)
self.dock1.setWidget(container)
# dock 2
QLabel('<h1 style="color:white;"> Hardware !</h1>', self.dock2).resize(
self.dock2.size().width() / 4, 25)
try:
audioDriverStr = {Solid.AudioInterface.Alsa: "ALSA",
Solid.AudioInterface.OpenSoundSystem: "Open Sound",
Solid.AudioInterface.UnknownAudioDriver: "Unknown?"}
audioInterfaceTypeStr = {
Solid.AudioInterface.AudioControl: "Control",
Solid.AudioInterface.UnknownAudioInterfaceType: "Unknown?",
Solid.AudioInterface.AudioInput: "In",
Solid.AudioInterface.AudioOutput: "Out"}
soundcardTypeStr = {
Solid.AudioInterface.InternalSoundcard: "Internal",
Solid.AudioInterface.UsbSoundcard: "USB3",
Solid.AudioInterface.FirewireSoundcard: "FireWire",
Solid.AudioInterface.Headset: "Headsets",
Solid.AudioInterface.Modem: "Modem"}
display = QTreeWidget()
display.setAlternatingRowColors(True)
display.setHeaderLabels(["Items", "ID", "Drivers", "I / O", "Type"])
display.setColumnWidth(0, 350)
display.setColumnWidth(1, 350)
display.setColumnWidth(3, 75)
# retrieve a list of Solid.Device for this machine
deviceList = Solid.Device.allDevices()
# filter the list of all devices and display matching results
# note that we never create a Solid.AudioInterface object, but
# receive one from the 'asDeviceInterface' call
for device in deviceList:
if device.isDeviceInterface(
Solid.DeviceInterface.AudioInterface):
audio = device.asDeviceInterface(
Solid.DeviceInterface.AudioInterface)
devtype = audio.deviceType()
devstr = []
for key in audioInterfaceTypeStr:
flag = key & devtype
if flag:
devstr.append(audioInterfaceTypeStr[key])
QTreeWidgetItem(display, [device.product(), audio.name(),
audioDriverStr[audio.driver()], "/".join(devstr),
soundcardTypeStr[audio.soundcardType()]])
self.dock2.setWidget(display)
except:
self.dock2.setWidget(QLabel(""" <center style='color:white;'>
<h1>:(<br>ERROR: Please, install PyKDE !</h1><br>
<br><i> (Sorry, can not use non-Qt Libs). Thanks </i><center>"""))
## dock 3
QLabel('<h1 style="color:white;"> Previews !</h1>', self.dock3).resize(
self.dock3.size().width() / 4, 25)
self.fileView = QColumnView()
self.fileView.updatePreviewWidget.connect(self.play)
self.fileView.setToolTip(' Browse and Preview Files ')
self.media = None
self.model = QDirModel()
self.fileView.setModel(self.model)
self.dock3.setWidget(self.fileView)
# dock4
QLabel('<h1 style="color:white;"> Setup !</h1>', self.dock4).resize(
self.dock4.size().width() / 4, 25)
self.group4 = QGroupBox()
self.group4.setTitle(__doc__)
self.combo0 = QComboBox()
self.combo0.addItems(['S16_LE', 'S32_LE', 'S16_BE', 'U16_LE', 'U16_BE',
'S24_LE', 'S24_BE', 'U24_LE', 'U24_BE', 'S32_BE', 'U32_LE', 'U32_BE'])
self.combo1 = QComboBox()
self.combo1.addItems(['1', '-1', '0', '2', '3', '4',
'5', '6', '7', '8', '9', '10'])
self.combo2 = QComboBox()
self.combo2.addItems(['128', '256', '512', '1024', '64', '32', '16'])
self.combo3 = QComboBox(self)
self.combo3.addItems(['MONO', 'STEREO', 'Surround'])
self.combo4 = QComboBox()
self.combo4.addItems(['44100', '96000', '48000', '32000',
'22050', '16000', '11025', '8000'])
self.combo5 = QComboBox(self)
self.combo5.addItems(['20', '19', '18', '17', '16', '15', '14', '13',
'12', '10', '9', '8', '7', '6', '5', '4', '3', '2', '1', '0'])
self.nepochoose = QCheckBox('Auto-Tag Files using Nepomuk Semantic')
self.chckbx0 = QCheckBox('Disable Software based Volume Control')
self.chckbx1 = QCheckBox('Output Sound Stereo-to-Mono Downmix')
self.chckbx2 = QCheckBox('Add Date and Time MetaData to Sound files')
self.chckbx3 = QCheckBox('Add Yourself as the Author Artist of Sound')
vboxg4 = QVBoxLayout(self.group4)
for each_widget in (
QLabel('<b style="color:white;"> Sound OGG Quality'), self.combo1,
QLabel('<b style="color:white;"> Sound Record Format'), self.combo0,
QLabel('<b style="color:white;"> Sound KBps '), self.combo2,
QLabel('<b style="color:white;"> Sound Channels '), self.combo3,
QLabel('<b style="color:white;"> Sound Sample Rate '), self.combo4,
QLabel('<b style="color:white;"> Sound Volume'), self.chckbx0,
QLabel('<b style="color:white;"> Sound Mix'), self.chckbx1,
QLabel('<b style="color:white;"> Sound Meta'), self.chckbx2,
QLabel('<b style="color:white;"> Sound Authorship'), self.chckbx3,
QLabel('<b style="color:white;"> CPUs Priority'), self.combo5,
QLabel('<b style="color:white;">Nepomuk Semantic User Experience'),
self.nepochoose):
vboxg4.addWidget(each_widget)
self.dock4.setWidget(self.group4)
# dock 5
QLabel('<h1 style="color:white;"> Voice Changer ! </h1>', self.dock5
).resize(self.dock5.size().width() / 3, 25)
self.group5 = QGroupBox()
self.group5.setTitle(__doc__)
self.dial = QDial()
self.dial.setCursor(QCursor(Qt.OpenHandCursor))
self.di_l = QLabel(self.dial)
self.di_l.resize(self.dial.size() / 8)
self.dial.sliderPressed.connect(lambda:
self.dial.setCursor(QCursor(Qt.ClosedHandCursor)))
self.dial.sliderReleased.connect(lambda:
self.dial.setCursor(QCursor(Qt.OpenHandCursor)))
self.dial.valueChanged.connect(lambda:
self.dial.setToolTip(str(self.dial.value())))
self.dial.valueChanged.connect(lambda: self.di_l.setText(
'<h1 style="color:white;">{}'.format(self.dial.value())))
self.dial.setValue(0)
self.dial.setMinimum(-999)
self.dial.setMaximum(999)
self.dial.setSingleStep(100)
self.dial.setPageStep(100)
self.dial.setWrapping(False)
self.dial.setNotchesVisible(True)
self.defo = QPushButton(QIcon.fromTheme("media-playback-start"), 'Run')
self.defo.setMinimumSize(self.defo.size().width(), 50)
self.defo.clicked.connect(lambda: self.process3.start(
'play -q -V0 "|rec -q -V0 -n -d -R riaa pitch {} "'
.format(self.dial.value()) if int(self.dial.value()) != 0 else
'play -q -V0 "|rec -q -V0 --multi-threaded -n -d -R bend {} "'
.format(' 3,2500,3 3,-2500,3 ' * 999)))
self.qq = QPushButton(QIcon.fromTheme("media-playback-stop"), 'Stop')
self.qq.clicked.connect(self.process3.kill)
self.die = QPushButton(QIcon.fromTheme("process-stop"), 'Kill')
self.die.clicked.connect(lambda: call('killall rec', shell=True))
vboxg5 = QVBoxLayout(self.group5)
for each_widget in (self.dial, self.defo, self.qq, self.die):
vboxg5.addWidget(each_widget)
self.dock5.setWidget(self.group5)
# configure some widget settings
must_be_checked((self.nepochoose, self.chckbx1,
self.chckbx2, self.chckbx3))
must_have_tooltip((self.label2, self.label4, self.label6, self.combo0,
self.nepochoose, self.combo1, self.combo2, self.combo3, self.combo4,
self.combo5, self.chckbx0, self.chckbx1, self.chckbx2, self.chckbx3,
self.rec, self.stop, self.defo, self.qq, self.die, self.kill,
self.button0, self.button1, self.button5))
must_autofillbackground((self.clock, self.label2, self.label4,
self.label6, self.nepochoose, self.chckbx0, self.chckbx1,
self.chckbx2, self.chckbx3))
must_glow((self.rec, self.dial, self.combo1))
self.nepomuk_get('testigo')
if self.auto is True:
self.go()
def play(self, index):
' play with delay '
if not self.media:
self.media = Phonon.MediaObject(self)
audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.media, audioOutput)
self.media.setCurrentSource(Phonon.MediaSource(
self.model.filePath(index)))
self.media.play()
def end(self):
' kill it with fire '
print((' INFO: Stoping Processes at {}'.format(str(datetime.now()))))
self.process1.terminate()
self.process2.terminate()
self.feedback.setText('''
<h5>Errors for RECORDER QProcess 1:</h5>{}<hr>
<h5>Errors for ENCODER QProcess 2:</h5>{}<hr>
<h5>Output for RECORDER QProcess 1:</h5>{}<hr>
<h5>Output for ENCODER QProcess 2:</h5>{}<hr>
'''.format(self.process1.readAllStandardError(),
self.process2.readAllStandardError(),
self.process1.readAllStandardOutput(),
self.process2.readAllStandardOutput(),
))
def killer(self):
' kill -9 '
QMessageBox.information(self.mainwidget, __doc__,
' KILL -9 was sent to the multi-process backend ! ')
self.process1.kill()
self.process2.kill()
def go(self):
' run timeout re-starting timers '
self.timerFirst.start(int(self.slider.value()) * 60 * 1000 + 2000)
self.timerSecond.start(int(self.slider.value()) * 60 * 1000 + 2010)
self.run()
def run(self):
' run forest run '
print((' INFO: Working at {}'.format(str(datetime.now()))))
chnl = 1 if self.combo3.currentText() == 'MONO' else 2
print((' INFO: Using {} Channels . . . '.format(chnl)))
btrt = int(self.combo4.currentText())
print((' INFO: Using {} Hz per Second . . . '.format(btrt)))
threshold = int(self.dial.value())
print((' INFO: Using Thresold of {} . . . '.format(threshold)))
print((' INFO: Using Recording time of {}'.format(self.slider.value())))
frmt = str(self.combo0.currentText()).strip()
print((' INFO: Using Recording quality of {} ...'.format(frmt)))
qlt = str(self.combo1.currentText()).strip()
print((' INFO: Using Recording quality of {} ...'.format(qlt)))
prio = str(self.combo5.currentText()).strip()
print((' INFO: Using CPU Priority of {} ...'.format(prio)))
downmix = '--downmix ' if self.chckbx1.isChecked() is True else ''
print((' INFO: Using Downmix is {} ...'.format(downmix)))
aut = '-a ' + getuser() if self.chckbx3.isChecked() is True else ''
print((' INFO: The Author Artist of this sound is: {}'.format(aut)))
T = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
tim = '--date {} '.format(T) if self.chckbx2.isChecked() is True else ''
print((' INFO: The Date and Time of this sound is: {}'.format(tim)))
vol = ' --disable-softvol' if self.chckbx0.isChecked() is True else ''
print((' INFO: Software based Volume Control is: {}'.format(vol)))
# make base directory
try:
mkdir(self.base)
print((' INFO: Base Directory path created {}'.format(self.base)))
except OSError:
print((' INFO: Base Directory already exist {}'.format(self.base)))
except:
print((' ERROR: Can not create Directory ?, {}'.format(self.base)))
# make directory tree
try:
for dr in range(1, 13):
mkdir(path.abspath(path.join(self.base, str(dr))))
print((' INFO:Directory created {}/{}'.format(self.base, dr)))
except OSError:
print((' INFO: Directory already exist {}/1,12'.format(self.base)))
except:
print((' ERROR: Cant create Directory?, {}/1,12'.format(self.base)))
# make new filename
flnm = path.abspath(path.join(self.base, str(datetime.now().month),
datetime.now().strftime("%Y-%m-%d_%H:%M:%S.ogg")))
self.actual_file = flnm
print((' INFO: Recording on the file {}'.format(flnm)))
# make custom commands
cmd1 = self.cmd1.format(n=prio, f=frmt, c=chnl, b=btrt, v=vol)
cmd2 = self.cmd2.format(c=chnl, b=btrt, q=qlt,
d=downmix, o=flnm, a=aut, t=tim)
print((cmd1, cmd2))
# multiprocess recording loop pipe
self.process1 = QProcess(self)
self.process2 = QProcess(self)
self.process1.setStandardOutputProcess(self.process2)
self.process1.start(cmd1)
if not self.process1.waitForStarted():
print((" ERROR: RECORDER QProcess 1 Failed: \n {} ".format(cmd1)))
self.process2.start(cmd2)
if not self.process2.waitForStarted():
print((" ERROR: ENCODER QProcess 2 Failed: \n {} ".format(cmd2)))
self.nepomuk_set(flnm, 'testigo', 'testigo', 'AutoTag by Cinta-Testigo')
def spectro(self):
' spectrometer '
wid = self.spec.size().width()
hei = self.spec.size().height()
command = self.cmd3.format(o=self.actual_file, x=wid, y=hei)
print(' INFO: Spectrometer is deleting OLD .ogg.png Files on target ')
call('rm --verbose --force {}/*/*.ogg.png'.format(self.base), shell=1)
print(' INFO: Spectrometer finished Deleting Files, Starting Render ')
call(command, shell=True)
print((''' INFO: Spectrometer finished Rendering Sound using:
{}{} OutPut: {}'''.format(command, linesep, self.actual_file)))
self.spec.setIcon(QIcon('{o}.png'.format(o=self.actual_file)))
self.spec.setIconSize(QSize(wid, hei))
self.spec.resize(wid, hei)
###########################################################################
def paintEvent(self, event):
'Paint semi-transparent background, animated pattern, background text'
QWidget.paintEvent(self, event)
# make a painter
p = QPainter(self)
p.setRenderHint(QPainter.TextAntialiasing)
p.setRenderHint(QPainter.HighQualityAntialiasing)
# fill a rectangle with transparent painting
p.fillRect(event.rect(), Qt.transparent)
# animated random dots background pattern
for i in range(4096):
x = randint(9, self.size().width() - 9)
y = randint(9, self.size().height() - 9)
p.setPen(QPen(QColor(randint(200, 255), randint(200, 255), 255), 1))
p.drawPoint(x, y)
# set pen to use white color
p.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255), 1))
# Rotate painter 45 Degree
p.rotate(35)
# Set painter Font for text
p.setFont(QFont('Ubuntu', 300))
# draw the background text, with antialiasing
p.drawText(99, 199, "Radio")
# Rotate -45 the QPen back !
p.rotate(-35)
# set the pen to no pen
p.setPen(Qt.NoPen)
# Background Color
p.setBrush(QColor(0, 0, 0))
# Background Opacity
p.setOpacity(0.75)
# Background Rounded Borders
p.drawRoundedRect(self.rect(), 50, 50)
# finalize the painter
p.end()
def seTitle(self):
' set the title of the main window '
dialog = QDialog(self)
textEditInput = QLineEdit(' Type Title Here ')
ok = QPushButton(' O K ')
ok.clicked.connect(lambda: self.setWindowTitle(textEditInput.text()))
ly = QVBoxLayout()
[ly.addWidget(wdgt) for wdgt in (QLabel('Title:'), textEditInput, ok)]
dialog.setLayout(ly)
dialog.exec_()
def timedate(self):
' get the time and date '
dialog = QDialog(self)
clock = QLCDNumber()
clock.setNumDigits(24)
timer = QTimer()
timer.timeout.connect(lambda: clock.display(
datetime.now().strftime("%d-%m-%Y %H:%M:%S %p")))
timer.start(1000)
clock.setToolTip(datetime.now().strftime("%c %x"))
ok = QPushButton(' O K ')
ok.clicked.connect(dialog.close)
ly = QVBoxLayout()
[ly.addWidget(wdgt) for wdgt in (QCalendarWidget(), clock, ok)]
dialog.setLayout(ly)
dialog.exec_()
def closeEvent(self, event):
' Ask to Quit '
if QMessageBox.question(self, ' Close ', ' Quit ? ',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def center(self):
' Center and resize the window '
self.showNormal()
self.resize(QDesktopWidget().screenGeometry().width() // 1.25,
QDesktopWidget().screenGeometry().height() // 1.25)
qr = self.frameGeometry()
qr.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(qr.topLeft())
def nepomuk_set(self, file_tag=None, __tag='', _label='', _description=''):
' Quick and Easy Nepomuk Taggify for Files '
print((''' INFO: Semantic Desktop Experience is Tagging Files :
{}, {}, {}, {})'''.format(file_tag, __tag, _label, _description)))
if Nepomuk.ResourceManager.instance().init() is 0:
fle = Nepomuk.Resource(KUrl(QFileInfo(file_tag).absoluteFilePath()))
_tag = Nepomuk.Tag(__tag)
_tag.setLabel(_label)
fle.addTag(_tag)
fle.setDescription(_description)
print(([str(a.label()) for a in fle.tags()], fle.description()))
return ([str(a.label()) for a in fle.tags()], fle.description())
else:
print(" ERROR: FAIL: Nepomuk is not running ! ")
def nepomuk_get(self, query_to_search):
' Quick and Easy Nepomuk Query for Files '
print((''' INFO: Semantic Desktop Experience is Quering Files :
{} '''.format(query_to_search)))
results = []
nepo = Nepomuk.Query.QueryServiceClient()
nepo.desktopQuery("hasTag:{}".format(query_to_search))
def _query(data):
''' ('filename.ext', 'file description', ['list', 'of', 'tags']) '''
results.append(([str(a.resource().genericLabel()) for a in data][0],
[str(a.resource().description()) for a in data][0],
[str(a.label()) for a in iter([a.resource().tags() for a in data][0]
)]))
nepo.newEntries.connect(_query)
def _end():
'''
[ ('filename.ext', 'file description', ['list', 'of', 'tags']),
('filename.ext', 'file description', ['list', 'of', 'tags']),
('filename.ext', 'file description', ['list', 'of', 'tags']) ]
'''
nepo.newEntries.disconnect
print(results)
return results
nepo.finishedListing.connect(_end)
class View (QFrame):
def __init__ (self, name, graph_view, scene, parent=None):
QFrame.__init__(self, parent)
self.graph_view = graph_view
self.graph_view.setView0 (self)
self.scene = scene
self.setFrameStyle (QFrame.Sunken | QFrame.StyledPanel)
self.font = QFont()
self.font.setPointSize(10)
self.graphicsView = CustomGraphicsView ()
self.graphicsView.setRenderHint (QPainter.Antialiasing, True)
self.graphicsView.setDragMode (QGraphicsView.RubberBandDrag)
self.graphicsView.setViewportUpdateMode (QGraphicsView.SmartViewportUpdate)
#self.graphicsView.setMouseTracking(True)
# toolbox definition + group page definition
sizePolicy = QSizePolicy (QSizePolicy.Fixed, QSizePolicy.Expanding)
self.setObjectName ('Form')
self.resize (900, 1000)
self._toolBox = QToolBox (self)
self._toolBox.setGeometry (QRect (0, 0, 131, 301))
self._toolBox.setFont (self.font)
self._toolBox.setObjectName ('_toolBox')
self._toolBox.setCursor (Qt.PointingHandCursor)
self.groupCluster = QWidget ()
self.groupCluster.setGeometry (QRect(0, 0, 91, 241))
self.groupCluster.setObjectName ('groupCluster')
self.groupLineEdit = QLineEdit (self.groupCluster)
self.groupLineEdit.setGeometry (QRect (2, 20, 60, 16))
self.groupLineEdit.setObjectName ('groupLineEdit')
self.label = QLabel (self.groupCluster)
self.label.setGeometry (QRect (4, 6, 62, 16))
self.label.setFont (self.font)
self.label.setObjectName ('label')
self.label_2 = QLabel (self.groupCluster)
self.label_2.setGeometry (QRect (4, 40, 62, 16))
self.label_2.setFont (self.font)
self.label_2.setObjectName ('label_2')
self.groupLineEdit_2 = QLineEdit (self.groupCluster)
self.groupLineEdit_2.setGeometry (QRect(2, 54, 60, 16))
self.groupLineEdit_2.setObjectName ('groupLineEdit_2')
self.pushButton = QPushButton (self.groupCluster)
self.pushButton.setGeometry (QRect (2, 90, 60, 16))
self.pushButton.setFont (self.font)
self.pushButton.setObjectName ('pushButton')
self._toolBox.addItem (self.groupCluster, '')
self._toolBox.setItemText (self._toolBox.indexOf (self.groupCluster), QApplication.translate ("Form", "Group", None, QApplication.UnicodeUTF8))
self.setWindowTitle (QApplication.translate ("Form", "Form", None, QApplication.UnicodeUTF8))
self.label.setText (QApplication.translate ("Form", "name group", None, QApplication.UnicodeUTF8))
self.label_2.setText (QApplication.translate ("Form", "group id", None, QApplication.UnicodeUTF8))
self.pushButton.setText (QApplication.translate ("Form", "add cluster", None, QApplication.UnicodeUTF8))
self._toolBox.setSizePolicy (sizePolicy)
self._toolBox.setEnabled (False)
# adding the first cluster to the toolbox - a cluster is always present!
self._cluster_page_list = []
self.connect (self.pushButton, SIGNAL ("clicked()"), self.addCluster) # connect the 'add-cluster' button to the method that taps into the model for cluster addition.
self.connect (self.graph_view.getComm(), SIGNAL ("addCluster_MSignal(int)"), self.addClusterPage)
self.connect (self.graph_view.getComm(), SIGNAL ("deleteCluster_MSignal(int)"), self.removeClusterPage)
self.connect (self.graph_view.getComm(), SIGNAL ("updateClusterName_MSignal(int, QString)"), self.updateClusterViewName)
self.addCluster () # add the first cluster. At least one cluster needs to be always present.
self.disableAllClusterPagesDeleteButton() # since there's only one cluster page, the delete button is disabled.
#size = self.style ().pixelMetric (QStyle.PM_ToolBarIconSize)
iconSize = QSize (16, 16) #QSize (size, size)
zoomInIcon = QToolButton ()
zoomInIcon.setCursor (Qt.PointingHandCursor)
zoomInIcon.setAutoRepeat (True)
zoomInIcon.setAutoRepeatInterval (33)
zoomInIcon.setAutoRepeatDelay (0)
zoomInIcon.setIconSize (iconSize)
zoomOutIcon = QToolButton ()
zoomOutIcon.setCursor (Qt.PointingHandCursor)
zoomOutIcon.setAutoRepeat (True)
zoomOutIcon.setAutoRepeatInterval (33)
zoomOutIcon.setAutoRepeatDelay (0)
zoomOutIcon.setIconSize (iconSize)
self.zoomSlider = QSlider ()
self.zoomSlider.setCursor (Qt.PointingHandCursor)
self.zoomSlider.setMinimum (200)
self.zoomSlider.setMaximum (280)
self.zoomSlider.setValue (240)
self.zoomSlider.setTickPosition (QSlider.TicksRight)
# Zoom slider layout
zoomSliderLayout = QVBoxLayout ()
zoomSliderLayout.addWidget (zoomInIcon)
zoomSliderLayout.addWidget (self.zoomSlider)
zoomSliderLayout.addWidget (zoomOutIcon)
self.printOutBtn = QPushButton()
self.printOutBtn.setText ("print")
self.printOutBtn.setFont (self.font)
self.printOutBtn.setEnabled (False)
self.newJADESceneBtn = QPushButton()
self.newJADESceneBtn.setText ("new")
self.newJADESceneBtn.setFont (self.font)
self.newJADESceneBtn.setEnabled (False)
self.loadNodesDescrpBtn = QPushButton()
self.loadNodesDescrpBtn.setText ("load Nodes Description")
self.loadNodesDescrpBtn.setFont (self.font)
self.loadNodesDescrpBtn.setEnabled (True)
self.graphLoadBtn = QPushButton()
self.graphLoadBtn.setText ("load")
self.graphLoadBtn.setFont (self.font)
self.graphLoadBtn.setEnabled (False)
self.graphSaveBtn = QPushButton()
self.graphSaveBtn.setText ("save")
self.graphSaveBtn.setFont (self.font)
self.graphSaveBtn.setEnabled (False)
self.resetButton = QToolButton ()
self.resetButton.setText ("r")
self.resetButton.setFont (self.font)
self.resetButton.setEnabled (False)
self.message_bar = QLineEdit ()
self.message_bar.setGeometry (QRect (0, 0, 190, 12))
self.message_bar.setObjectName ('message_bar')
self.message_bar.setText ('Node description file, please.')
self.message_bar.setFont (self.font)
self.message_bar.setEnabled (True)
self.message_bar.setReadOnly (True)
self.spacer = QSpacerItem (30, 20, QSizePolicy.Fixed, QSizePolicy.Fixed );
# Label layout
labelLayout = QHBoxLayout ()
self.label = QLabel (name)
self.label.setFont (self.font)
labelLayout.addWidget (self.loadNodesDescrpBtn)
labelLayout.addWidget (self.newJADESceneBtn)
labelLayout.addWidget (self.graphLoadBtn)
labelLayout.addWidget (self.graphSaveBtn)
labelLayout.addWidget (self.printOutBtn)
labelLayout.addItem (self.spacer)
labelLayout.addWidget (self.message_bar)
#labelLayout.addWidget (self.label)
labelLayout.addStretch ()
# top layout
topLayout = QGridLayout ()
topLayout.setHorizontalSpacing (0)
topLayout.setVerticalSpacing (0)
topLayout.addLayout (labelLayout, 0, 1)
topLayout.addWidget (self._toolBox, 1, 0)
topLayout.addWidget (self.resetButton, 0, 2)
topLayout.addWidget (self.graphicsView, 1, 1)
topLayout.addLayout (zoomSliderLayout, 1, 2)
self.setLayout (topLayout)
self.connect (self.resetButton, SIGNAL ("clicked()"), self.resetView)
self.connect (self.zoomSlider, SIGNAL ("valueChanged(int)"), self.setupMatrix)
self.connect (self.graphicsView.verticalScrollBar (), SIGNAL ("valueChanged(int)"), self.setResetButtonEnabled)
self.connect (self.graphicsView.horizontalScrollBar (), SIGNAL ("valueChanged(int)"), self.setResetButtonEnabled)
self.connect (zoomInIcon, SIGNAL ("clicked()"), self.zoomIn)
self.connect (zoomOutIcon, SIGNAL ("clicked()"), self.zoomOut)
self.setupMatrix ()
self.printer = QPrinter (QPrinter.HighResolution)
self.prev_selection_list = []
self.isClusterRemovalOverridden = False
def setMessageBarText (self, text):
self.message_bar.setText (text)
def enableControls (self):
self.printOutBtn.setEnabled (True)
self.newJADESceneBtn.setEnabled (True)
self.graphLoadBtn.setEnabled (True)
self.graphSaveBtn.setEnabled (True)
self._toolBox.setEnabled (True)
def disableControls (self):
self.printOutBtn.setEnabled (False)
self.newJADESceneBtn.setEnabled (False)
self.graphLoadBtn.setEnabled (False)
self.graphSaveBtn.setEnabled (False)
self._toolBox.setEnabled (False)
def setGraphicsViewCSSBackground (self):
self.graphicsView.setStyleSheet('background-color: qlineargradient(spread:pad, x1:0, y1:1, x2:0, y2:0, stop:0 rgba(125, 125, 135, 255), stop:1 rgba(215, 215, 215, 255));\ncolor: rgb(255, 255, 255);')
def selectionChanged (self):
current_selection_list = self.scene.selectedItems ()
list_of_unselected_items = [item for item in self.prev_selection_list if item not in current_selection_list]
# un-mark items in list_of_unselected_items
for item in list_of_unselected_items:
if self.graph_view.isTag (item) == True:
item.switchToUnSelectedStateColour ()
# mark items in current_selection_list
for item in current_selection_list:
if self.graph_view.isTag (item) == True:
item.switchToSelectedStateColour ()
self.prev_selection_list = current_selection_list
# - - - cluster-specific methods - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def addCluster (self):
self.graph_view.delegateClusterAddition ()
def addClusterPage (self, new_cluster_id):
self.enableAllClusterPagesDeleteButton () # enable all the cluster page's delete buttons (as I can be bothered to go look for the one that got previously disabled)
tmp_w = QWidget ()
tmp_l = QLabel (tmp_w)
tmp_e = QLineEdit (tmp_w)
tmp_b = QPushButton (tmp_w)
self._cluster_page_list.append ([new_cluster_id, tmp_w, tmp_l, tmp_e, tmp_b])
tmp_w.setGeometry (QRect (0, 0, 131, 241))
tmp_w.setObjectName ('Cluster_' + str (new_cluster_id))
tmp_l.setGeometry (QRect (4, 6, 62, 16))
tmp_l.setFont (self.font)
tmp_l.setObjectName ('label_' + str (new_cluster_id))
tmp_e.setGeometry (QRect (2, 20, 60, 16))
tmp_e.setObjectName ('groupLineEdit_' + str (new_cluster_id))
tmp_b.setGeometry (QRect (2, 50, 60, 16))
tmp_b.setFont (self.font)
tmp_b.setObjectName ('pushButton_' + str (new_cluster_id))
self._toolBox.addItem (tmp_w, 'cluster_page_'+str(new_cluster_id))
self._toolBox.setItemText (self._toolBox.indexOf (tmp_w), QApplication.translate ('Form', 'C_'+str(new_cluster_id), None, QApplication.UnicodeUTF8))
tmp_l.setText (QApplication.translate ("Form", "name cluster", None, QApplication.UnicodeUTF8))
tmp_b.setText (QApplication.translate ("Form", "delete", None, QApplication.UnicodeUTF8))
self._toolBox.setCurrentIndex (new_cluster_id)
QMetaObject.connectSlotsByName (self)
# hook up the delete button (use a closure)
receiver = lambda : self.removeCluster (new_cluster_id)
self.connect (tmp_b, SIGNAL ("clicked()"), receiver) # connect the 'add cluster' button to the method generating new cluster pages.
receiver2 = lambda value : self.updateClusterModelName (new_cluster_id, value)
self.connect (tmp_e, SIGNAL ("textChanged(QString)"), receiver2)
def removeAllClusters (self):
copy_list = list (self._cluster_page_list)
self.isClusterRemovalOverridden = True
for item in copy_list:
self.removeCluster (item[0])
self.graph_view.initGraphViewLists ()
self.graph_view.initComm ()
self.graph_view.initModel ()
self._cluster_page_list = []
self.addCluster () # add the first cluster. At least one cluster needs to be always present.
self.isClusterRemovalOverridden = False # remove override
def removeCluster (self, cluster_id):
self.graph_view.delegateClusterRemoval (cluster_id)
def removeClusterPage (self, cluster_id):
threshold = 1 if self.isClusterRemovalOverridden==False else 0
qq = len(self._cluster_page_list)
if qq > threshold:
for i in range (qq-1, -1, -1):
if int(self._cluster_page_list[i][0]) == cluster_id:
self._toolBox.removeItem (self._toolBox.indexOf(self._cluster_page_list[i][1]))
del self._cluster_page_list[i]
break
if len(self._cluster_page_list) == 1:
self.disableAllClusterPagesDeleteButton ()
def disableAllClusterPagesDeleteButton (self):
if len(self._cluster_page_list) > 0:
for item in self._cluster_page_list:
item[4].setEnabled (False)
def enableAllClusterPagesDeleteButton (self):
if len(self._cluster_page_list) > 0:
for item in self._cluster_page_list:
item[4].setEnabled (True)
def updateClusterModelName (self, cluster_id, text):
self.graph_view.delegateUpdateClusterName (cluster_id, text)
def updateClusterViewName (self, cluster_id, text):
if len(self._cluster_page_list) > 0:
for item in self._cluster_page_list:
if int(item[0]) == cluster_id:
item[3].setText (str(text))
def updateCurrentClusterNodeList (self, node):
# fetch the current cluster's id.
curr_widget = self._toolBox.currentWidget()
for item in self._cluster_page_list:
if item[1] == curr_widget:
# delegate cluster node list update.
self.graph_view.delegateClusterNodeListUpdate (item[0], node)
break
def getCurrentClusterIndex (self):
return self._toolBox.currentIndex ()
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def getGraphicsView (self):
return self.graphicsView
def resetView (self):
self.zoomSlider.setValue (250)
self.setupMatrix ()
self.graphicsView.ensureVisible (QRectF (0, 0, 0, 0))
self.resetButton.setEnabled (False)
def setResetButtonEnabled (self):
self.resetButton.setEnabled (True)
def setupMatrix (self):
scale = pow (2.0, (self.zoomSlider.value () - 250) / 50.0)
matrix = QMatrix ()
matrix.scale (scale, scale)
self.graphicsView.setMatrix (matrix)
self.setResetButtonEnabled ()
def printOutGraph (self):
qqq = QPainter (self.printer)
self.graphicsView.render(qqq)
def importNodesDescription (self):
aa = QFileDialog (self).getOpenFileName()
if aa != QString (u''): # it can be equal to QString(u'') when the user presses the Escape key, so in that circumstance, nothing is returned.
self.graph_view.setNodesDescription (open(aa).read())
def resetScene (self):
self.removeAllClusters ()
self.resetView ()
def exportGraph (self):
aa = QFileDialog (self).getSaveFileName ()
if aa != QString (u''): # it can be equal to QString(u'') when the user presses the Escape key, so in that circumstance, nothing is returned.
file0 = open (aa, 'w')
file0.write (self.graph_view.delegateExport ())
file0.close ()
print '\n*** file exported.\n'
def importGraph (self):
aa = QFileDialog (self).getOpenFileName ()
if aa != QString (u''): # it can be equal to QString(u'') when the user presses the Escape key, so in that circumstance, nothing is returned.
file0 = open (aa, 'r')
XML_content = file0.read()
file0.close ()
self.graph_view.delegateImport (XML_content)
print '\n*** file imported.\n'
# zoom slider
def zoomIn (self) : self.zoomSlider.setValue (self.zoomSlider.value() + 1)
def zoomOut (self) : self.zoomSlider.setValue (self.zoomSlider.value() - 1)
def getZoomSlider (self): return self.zoomSlider
def setToolboxCSSColorScheme (self, css): self._toolBox.setStyleSheet (css)
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def wireViewItemsUp (self):
self.connect (self.newJADESceneBtn, SIGNAL ("clicked()"), self.resetScene)
self.connect (self.loadNodesDescrpBtn, SIGNAL ("clicked()"), self.importNodesDescription)
self.connect (self.graphSaveBtn, SIGNAL ("clicked()"), self.exportGraph)
self.connect (self.graphLoadBtn, SIGNAL ("clicked()"), self.importGraph)
self.connect (self.printOutBtn, SIGNAL ("clicked()"), self.printOutGraph)
class Window(QMainWindow):
def __init__(self,parent = None):
QMainWindow.__init__(self,parent)
self.setObjectName("self")
self.resize(758, 673)
self.setWindowTitle("Sabel")
self.setWindowIcon(Icons.sabel)
self.centralwidget = QWidget(self)
self.centralwidget.setObjectName("centralwidget")
self.horizontalLayout = QHBoxLayout(self.centralwidget)
self.horizontalLayout.setObjectName("horizontalLayout")
self.horizontalLayout.setMargin(0)
self.styleIndex = styleIndex
#TabWidgets
self.tab_1 = QWidget(self)
self.tab_1.setObjectName("tab_1")
self.tab_1.setMinimumWidth(800)
self.tabWidget = Tab(self.tab_1)
self.tabWidget.setObjectName("tabWidget")
self.VericalLayout = QVBoxLayout(self.tab_1)
self.VericalLayout.setMargin(0)
self.VericalLayout.setObjectName("VericalLayout")
self.VericalLayout.addWidget(self.tabWidget)
self.tabWidget_2 = QTabWidget(self)
#self.tabWidget_2.setMaximumWidth(200)
self.tabWidget_2.setObjectName("tabWidget_2")
self.tabWidget_3 = QTabWidget(self)
self.tabWidget_3.setMaximumHeight(260)
self.tabWidget_3.setObjectName("tabWidget_3")
#Tree
self.tab_5 = QWidget()
self.tab_5.setObjectName("tab_5")
#self.tab_5.setMaximumWidth(200)
self.VerticalLayout_2 = QVBoxLayout(self.tab_5)#QHBoxLayout(self.tab_5)
self.VerticalLayout_2.setMargin(0)
self.VerticalLayout_2.setObjectName("horizontalLayout_3")
self.treeWidget = Tree(self.tab_5)
self.treeWidget.setObjectName("treeWidget")
self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.treeWidget.horizontalScrollBar().show()
self.treebar = QToolBar()
action_Folder = QAction(Icons.newfolder,'New Folder', self)
action_Folder.triggered.connect(self.about)
action_Android = QAction(Icons.android,'Android', self)
action_Android.triggered.connect(self.android)
action_Ant = QAction(Icons.ant_view,'Ant', self)
action_Ant.triggered.connect(self.ant)
self.treebar.addAction(action_Folder)
self.treebar.addAction(action_Android)
self.treebar.addAction(action_Ant)
self.treebar.setIconSize(QSize(16,16))
self.VerticalLayout_2.addWidget(self.treebar)
self.VerticalLayout_2.addWidget(self.treeWidget)
#Outline
self.tab_2 = QWidget()
self.tab_2.setObjectName("tab_2")
#self.tab_2.setMaximumWidth(200)
self.VerticalLayout_3 = QVBoxLayout(self.tab_2)
self.VerticalLayout_3.setMargin(0)
self.VerticalLayout_3.setObjectName("VerticalLayout_3")
self.outlineWidget = Tree(self.tab_2)
self.outlineWidget.setObjectName("outlineWidget")
self.VerticalLayout_3.addWidget(self.outlineWidget)
#Output
self.tab_6 = QWidget()
self.tab_6.setObjectName("tab_6")
#GGGGGGGGGGGGGGGGGGGG AWESOME
self.horizontalLayout_2 = QVBoxLayout(self.tab_6)
self.horizontalLayout_2.setMargin(0)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.textEdit = QTextEdit(self.tab_6)
self.textEdit.setObjectName("textEdit")
self.lineeEdit = QLineEdit(self.tab_6)
self.lineeEdit.setObjectName("lineeEdit")
self.label = QLabel(self.tab_6)
self.label.setText("Input:")
self.horizontalLayout_2.addWidget(self.textEdit)
self.horizontalLayout_2.addWidget(self.label)
self.horizontalLayout_2.addWidget(self.lineeEdit)
#Error
self.tab_7 = QWidget()
self.tab_7.setObjectName("tab_7")
self.horizontalLayout_4 = QHBoxLayout(self.tab_7)
self.horizontalLayout_4.setMargin(0)
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
self.textEdit_2 = QTextEdit(self.tab_7)
self.textEdit_2.setObjectName("textEdit_2")
self.horizontalLayout_4.addWidget(self.textEdit_2)
#Find
self.tab_8 = QWidget()
self.tab_8.setObjectName("tab_8")
self.horizontalLayout_5 = QHBoxLayout(self.tab_8)
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.lineEdit = QLineEdit(self.tab_8)
self.lineEdit.setObjectName("lineEdit")
self.lineEdit_2 = QLineEdit(self.tab_8)
self.lineEdit_2.setObjectName("lineEdit_2")
self.findClose = QPushButton(self.tab_8)
self.findClose.setIcon(Icons.close_view)
self.findClose.setFlat(True)
self.findClose.clicked.connect(self.findBarShow)
self.find = QPushButton(self.tab_8)
self.find.setText("Find")
self.find.clicked.connect(self.findCurrentText)
self.replacefind = QPushButton(self.tab_8)
self.replacefind.setText("Replace/Find")
self.replace = QPushButton(self.tab_8)
self.replace.setText("Replace")
self.replace.clicked.connect(self.replaceCurrentText)
self.replaceAll = QPushButton(self.tab_8)
self.replaceAll.setText("Replace All")
self.replaceAll.clicked.connect(self.replaceAllText)
self.caseSensitive = QToolButton(self.tab_8)
self.caseSensitive.setText("cs")
self.caseSensitive.setCheckable(True)
self.wholeWord = QToolButton(self.tab_8)
self.wholeWord.setText("ww")
self.wholeWord.setCheckable(True)
self.regex = QToolButton(self.tab_8)
self.regex.setText("re")
self.regex.setCheckable(True)
self.backward = QToolButton(self.tab_8)
self.backward.setText("bk")
self.backward.setCheckable(True)
self.backward.setDisabled(True)
self.horizontalLayout_5.addWidget(self.findClose)
self.horizontalLayout_5.addWidget(self.find)
self.horizontalLayout_5.addWidget(self.lineEdit)
self.horizontalLayout_5.addWidget(self.lineEdit_2)
self.horizontalLayout_5.addWidget(self.caseSensitive)
self.horizontalLayout_5.addWidget(self.wholeWord)
self.horizontalLayout_5.addWidget(self.regex)
self.horizontalLayout_5.addWidget(self.backward)
self.horizontalLayout_5.addWidget(self.replacefind)
self.horizontalLayout_5.addWidget(self.replace)
self.horizontalLayout_5.addWidget(self.replaceAll)
self.horizontalLayout_5.setMargin(0)
self.tab_8.setMaximumHeight(25)
self.VericalLayout.addWidget(self.tab_8)
self.tab_8.hide()
self.tabWidget_2.addTab(self.tab_5,"Projects")
self.tabWidget_2.addTab(self.tab_2,"Outline")
self.tabWidget_3.addTab(self.tab_7,"Error")
self.tabWidget_3.addTab(self.tab_6,"Output")
self.tabWidget_3.setTabIcon(0,Icons.error)
self.tabWidget_3.setTabIcon(1,Icons.console_view)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setTabShape(0)
#Splitters
self.split1 = QSplitter(Qt.Horizontal)
self.split1.addWidget(self.tabWidget_2)
self.split1.addWidget(self.tab_1)
#self.split1.addWidget(self.tab_5)
self.split2 = QSplitter(Qt.Vertical)
self.split2.addWidget(self.split1)
self.split2.addWidget(self.tabWidget_3)
self.tabWidget_3.hide()
self.horizontalLayout.addWidget(self.split2)
#Status
self.statusbar = QStatusBar(self)
self.statusbar.setObjectName("statusbar")
self.aboutButton = QPushButton(self)
self.aboutButton.setFlat(True)
self.aboutButton.setIcon(Icons.anchor)
self.aboutButton.clicked.connect(self.about)
self.cmdButton = QPushButton(self)
self.cmdButton.setFlat(True)
self.cmdButton.setIcon(Icons.console_view)
self.cmdButton.clicked.connect(self.cmd)
self.cmdButton.setShortcut('Ctrl+O')
self.findButton = QPushButton(self)
self.findButton.setFlat(True)
self.findButton.setIcon(Icons.find)
self.findButton.setShortcut("Ctrl+F")
self.findButton.clicked.connect(self.findBarShow)
self.zoominButton = QPushButton(self)
self.zoominButton.setFlat(True)
self.zoominButton.setIcon(Icons.zoomplus)
self.zoominButton.clicked.connect(self.zoomin)
self.zoomoutButton = QPushButton(self)
self.zoomoutButton.setFlat(True)
self.zoomoutButton.setIcon(Icons.zoomminus)
self.zoomoutButton.clicked.connect(self.zoomout)
self.fontButton = QPushButton(self)
self.fontButton.setFlat(True)
self.fontButton.setIcon(Icons.font)
self.fontButton.clicked.connect(self.setFont)
self.statusbar.addWidget(self.aboutButton)
self.statusbar.addWidget(self.cmdButton)
self.statusbar.addWidget(self.findButton)
self.statusbar.addWidget(self.zoominButton)
self.statusbar.addWidget(self.zoomoutButton)
self.statusbar.addWidget(self.fontButton)
#self.statusbar.setFixedHeight(18)
#Init colorstyling
self.colorStyle = None
self.initColorStyle()
#Init
self.setCentralWidget(self.centralwidget)
self.setStatusBar(self.statusbar)
self.textEdit.setReadOnly(True)
self.fontName = fontName
#QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))
def findBarShow(self):
if(self.tab_8.isHidden()):
self.tab_8.show()
else:
self.tab_8.hide()
def initToolBar(self):
self.action_NewProject = QAction(Icons.newprj, 'Project', self)
self.action_NewProject.setShortcut('Ctrl+P')
self.action_NewProject.triggered.connect(self.newProject)
self.action_NewProject.setToolTip("Create a New Project")
self.action_NewProject.setStatusTip("Create a New Project")
self.action_Open = QAction(Icons.open, 'Open', self)
self.action_Open.setShortcut('Ctrl+O')
self.action_Open.triggered.connect(self.fileOpen)
self.action_Open.setToolTip("Open File")
self.action_Open.setStatusTip("Open File")
self.action_Save = QAction(Icons.save, 'Save', self)
self.action_Save.setShortcut('Ctrl+S')
self.action_Save.triggered.connect(self.fileSave)
self.action_Save.setToolTip("Save Current File")
self.action_SaveAll = QAction(Icons.saveall, 'SaveAll', self)
self.action_SaveAll.setShortcut('Ctrl+A')
self.action_SaveAll.triggered.connect(self.fileSaveAll)
self.action_SaveAll.setToolTip("Save All Files")
self.action_Help = QAction(Icons.toc_open, 'Help', self)
self.action_Help.triggered.connect(self.help)
self.action_Run = QAction(Icons.run, 'Run', self)
self.action_Run.setShortcut('Ctrl+R')
self.action_Run.triggered.connect(self.adb.run)
self.action_RunFile = QAction(Icons.go, 'File', self)
self.action_RunFile.triggered.connect(self.command.setCmd)
self.lineeEdit.returnPressed.connect(self.command.setCmdLine)
self.action_Stop = QAction(Icons.stop, 'Stop', self)
self.action_Stop.setShortcut('Ctrl+Q')
self.action_Stop.triggered.connect(self.adb.stop)
self.action_Design = QAction(Icons.task_set, 'Design', self)
self.action_Todo = QAction(Icons.task_set, 'Todo', self)
#self.action_Todo.triggered.connect(self.stop)
#Only variation CHeck Later
men = QMenu()
self.threshSlider = QSlider()
self.threshSlider.setTickPosition(QSlider.TicksLeft)
self.threshSlider.setOrientation(Qt.Horizontal)
self.threshSlider.setValue(threshold)
self.threshSlider.setMinimum(0)
self.threshSlider.setMaximum(5)
self.threshSlider.valueChanged.connect(self.setThreshold)
#self.threshSlider.setInvertedAppearance(True)
self.threshSliderAction = QWidgetAction(men)
self.threshSliderAction.setDefaultWidget(self.threshSlider)
men.addAction(QAction("Ident",self))
men.addAction(QAction("Edit",self))
men.addAction(QAction("Paste",self))
men.addAction(QAction("Tabs",self))
men.addSeparator()
men.addAction(QAction("Threshold",self))
men.addAction(self.threshSliderAction)
self.action_Options = QAction(Icons.thread_view, 'Options', self)
self.action_Options.setMenu(men)
self.action_Options.triggered.connect(self.options)
self.action_Full = QAction(Icons.fullscreen, 'Full', self)
self.action_Full.setShortcut('Shift+Enter')
self.action_Full.triggered.connect(self.full)
self.action_Style = QAction(Icons.style, 'Style', self)
men1 = QMenu()
self.styleslist = []
self.style1 = QAction("All Hallow's Eve",self)
self.style1.triggered.connect(lambda:self.style_clicked(1))
self.style1.setCheckable(True)
self.style2 = QAction("Amy",self)
self.style2.triggered.connect(lambda:self.style_clicked(2))
self.style2.setCheckable(True)
self.style3 = QAction("Aptana Studio",self)
self.style3.triggered.connect(lambda:self.style_clicked(3))
self.style3.setCheckable(True)
self.style4 = QAction("Bespin",self)
self.style4.triggered.connect(lambda:self.style_clicked(4))
self.style4.setCheckable(True)
self.style5 = QAction("Blackboard",self)
self.style5.triggered.connect(lambda:self.style_clicked(5))
self.style5.setCheckable(True)
self.style6 = QAction("Choco",self)
self.style6.triggered.connect(lambda:self.style_clicked(6))
self.style6.setCheckable(True)
self.style7 = QAction("Cobalt",self)
self.style7.triggered.connect(lambda:self.style_clicked(7))
self.style7.setCheckable(True)
self.style8 = QAction("Dawn",self)
self.style8.triggered.connect(lambda:self.style_clicked(8))
self.style8.setCheckable(True)
self.style9 = QAction("Eclipse",self)
self.style9.triggered.connect(lambda:self.style_clicked(9))
self.style9.setCheckable(True)
self.styleslist.append(self.style1)
self.styleslist.append(self.style2)
self.styleslist.append(self.style3)
self.styleslist.append(self.style4)
self.styleslist.append(self.style5)
self.styleslist.append(self.style6)
self.styleslist.append(self.style7)
self.styleslist.append(self.style8)
self.styleslist.append(self.style9)
men1.addActions(self.styleslist)
self.action_Style.setMenu(men1)
self.styleslist[self.styleIndex].setChecked(True)
self.action_Stop.setDisabled(True)
self.toolbar = self.addToolBar('ToolBar')
self.toolbar.setIconSize(QSize(16,16))
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.toolbar.setAllowedAreas(Qt.AllToolBarAreas)
#self.toolbar.setFixedHeight(40)
self.toolbar.addAction(self.action_NewProject)
self.toolbar.addAction(self.action_Open)
self.toolbar.addAction(self.action_Save)
self.toolbar.addAction(self.action_SaveAll)
self.toolbar.addSeparator()
self.toolbar.addAction(self.action_Run)
self.toolbar.addAction(self.action_RunFile)
self.toolbar.addAction(self.action_Stop)
self.toolbar.addSeparator()
self.toolbar.addAction(self.action_Design)
self.toolbar.addAction(self.action_Todo)
self.toolbar.addAction(self.action_Options)
self.toolbar.addAction(self.action_Style)
self.toolbar.addSeparator()
self.toolbar.addAction(self.action_Help)
self.toolbar.addAction(self.action_Full)
def about(self):
QMessageBox.about(self, "About Sabel IDE",
"""
<b>Sabel</b> v%s
<p>
All rights reserved in accordance with
GPL v3 or later.
<p>This application can be used for Squirrel and EmoFramework Projects.
<p>Squirrel Shell Copyright (c) 2006-2011, Constantin Makshin
<p>Squirrel Copyright (c) Alberto Demichelis
<p>zlib Copyright (c) Jean-loup Gailly and Mark Adler
<p>Icons Copyright (c) Eclipse EPL
<p>Emo-Framework Copyright (c) 2011 Kota Iguchi
<p>Python %s - Qt %s - PyQt %s on %s
<p>Created By: pyros2097
<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
""" % (
__version__,PY_VERSION,
QT_VERSION_STR, PYQT_VERSION_STR,OS_NAME))
def help(self):
QMessageBox.about(self, "About Simple Editor","This is The Help")
def full(self):
if not self.isFull:
self.setWindowState(Qt.WindowFullScreen)
self.isFull = True
else:
self.setWindowState(Qt.WindowMaximized)
self.isFull = False
def android(self):
form = DialogAndroid(self)
form.show()
def ant(self):
pass
def cmd(self):
if(self.tabWidget_3.isHidden()):
self.tabWidget_3.show()
else:
self.tabWidget_3.hide()
def findCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())
def replaceCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
done = edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())
if(done):
edt.replaceText(self.lineEdit_2.text())
else:
QMessageBox.about(self, "About Sabel IDE","Could Not Find Text")
return done
def replaceAllText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
while(edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())):
edt.replaceText(self.lineEdit_2.text())
def zoomin(self):
for i in range(len(self.files)):
self.tabWidget.widget(i).zoomin()
def zoomout(self):
for i in range(len(self.files)):
self.tabWidget.widget(i).zoomout()
def setFont(self):
font = QFont()
font.setFamily(self.fontName)
fdialog = QFontDialog(self)
fdialog.show()
fdialog.setCurrentFont(font)
fdialog.accepted.connect(lambda:self.setFontName(fdialog.currentFont()))
def setFontName(self,font):
#print "accepted"
#print font.family()
self.fontName = str(font.family())
config.setFontName(self.fontName)
for i in range(len(self.files)):
self.tabWidget.widget(i).setFontName(self.fontName)
def setThreshold(self,val):
config.setThresh(val)
for i in range(len(self.files)):
self.tabWidget.widget(i).setThreshold(val)
def initColorStyle(self):
self.colorStyle = Styles[self.styleIndex]
pal = QPalette(self.tabWidget_2.palette())
#print pal.color(QPalette.Base).name()
#print pal.color(QPalette.Window).name()
pal.setColor(QPalette.Base,self.colorStyle.paper)
pal.setColor(QPalette.Text,self.colorStyle.color)
self.tabWidget_2.setPalette(pal)
self.tabWidget_3.setPalette(pal)
def style_clicked(self,no):
self.styleIndex = no -1
#print self.styleIndex
for i in self.styleslist:
if self.styleslist.index(i) == self.styleIndex:
i.setChecked(True)
else:
i.setChecked(False)
config.setstyleIndex(self.styleIndex)
#self.initColorStyle()
for i in range(len(self.files)):
pass
#self.tabWidget.
#self.tabWidget.widget(i).setColorStyle(self.colorStyle)
