class ScreenShot(QWidget):
def __init__(self):
super(ScreenShot, self).__init__()
self.initUI()
def initUI(self):
self.originalPixmap = QPixmap()
self.screenshotLabel = QLabel("screenshotlabel", self)
self.screenshotLabel.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.screenshotLabel.setAlignment(Qt.AlignCenter)
self.screenGeometry = QApplication.desktop().screenGeometry(
) # Qrect()
print self.screenGeometry, self.screenGeometry.width()
self.screenshotLabel.setMinimumSize(self.screenGeometry.width() / 8,
self.screenGeometry.height() / 8)
mainlayout = QVBoxLayout(self)
mainlayout.addWidget(self.screenshotLabel)
self.optionsGroupBox = QGroupBox(u"选项", self)
self.hideThisWindowCheckBox = QCheckBox(u"隐藏这个窗口",
self.optionsGroupBox)
self.optionsGroupBoxLayout = QGridLayout(self.optionsGroupBox)
mainlayout.addWidget(self.optionsGroupBox)
self.delaySpinBox = QSpinBox(self.optionsGroupBox)
self.delaySpinBox.setSuffix(u"s")
self.delaySpinBox.setMaximum(60)
self.optionsGroupBoxLayout.addWidget(QLabel(u"截屏延时:", self), 0, 0)
self.optionsGroupBoxLayout.addWidget(self.delaySpinBox, 0, 1)
self.optionsGroupBoxLayout.addWidget(self.hideThisWindowCheckBox, 1, 0)
buttonLayout = QHBoxLayout()
self.newScreenshotButton = QPushButton(u"新截图", self)
self.newScreenshotButton.clicked.connect(self.__newScreenshot)
buttonLayout.addWidget(self.newScreenshotButton)
saveScreenshotButton = QPushButton(u"保存截图", self)
buttonLayout.addWidget(saveScreenshotButton)
quitScreenshotButton = QPushButton(u"退出截图", self)
quitScreenshotButton.setShortcut("Ctrl+Q")
buttonLayout.addWidget(saveScreenshotButton)
buttonLayout.addStretch()
mainlayout.addLayout(buttonLayout)
quitScreenshotButton.clicked.connect(self.close)
saveScreenshotButton.clicked.connect(self.__saveScreenshot)
self.delaySpinBox.valueChanged.connect(self.__updateCheckBox)
self.delaySpinBox.setValue(5)
self.setWindowTitle(u"截图")
self.resize(300, 200)
def resizeEvent(self, QResizeEvent):
scaledSize = self.originalPixmap.size()
scaledSize.scale(self.screenshotLabel.size(), Qt.KeepAspectRatio)
if (not self.screenshotLabel.pixmap()) or (
scaledSize != self.screenshotLabel.pixmap().size()):
self.__updateScreenshotLabel()
def __newScreenshot(self):
if self.hideThisWindowCheckBox.isChecked():
self.hide()
self.newScreenshotButton.setDisabled(True)
QTimer.singleShot(self.delaySpinBox.value() * 1000, self.__shootScreen)
def __saveScreenshot(self):
format = "png"
initialPath = QDesktopServices.storageLocation(
QDesktopServices.PicturesLocation)
# initialPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
if initialPath.isEmpty():
initialPath = QDir.currentPath()
initialPath += "/untitled." + format
fileDialog = QtGui.QFileDialog(self, u"存储为", initialPath)
fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
fileDialog.setDirectory(initialPath)
mimeTypes = QStringList()
for bf in QImageWriter.supportedImageFormats():
mimeTypes.append(QLatin1String(bf))
# fileDialog.setMin setMimeTypeFilters(mimeTypes)
# fileDialog.selectMimeTypeFilter("image/" + format);
fileDialog.setDefaultSuffix(format)
if fileDialog.accept():
return
fileName = fileDialog.selectedFiles().first()
if not self.originalPixmap.save(fileName):
QtGui.QMessageBox.Warning(
self, u"保存错误",
u"图像无法存储到 \"%s\"." % str(QDir.toNativeSeparators(fileName)))
def __shootScreen(self):
if self.delaySpinBox.value() != 0:
QApplication.beep()
self.originalPixmap = QPixmap.grabWindow(
QApplication.desktop().winId())
self.__updateScreenshotLabel()
self.newScreenshotButton.setDisabled(False)
if self.hideThisWindowCheckBox.isChecked():
self.show()
def __updateCheckBox(self):
print "sssss"
if self.delaySpinBox.value() == 0:
self.hideThisWindowCheckBox.setDisabled(True)
self.hideThisWindowCheckBox.setChecked(False)
else:
self.hideThisWindowCheckBox.setDisabled(False)
def __updateScreenshotLabel(self):
self.screenshotLabel.setPixmap(
self.originalPixmap.scaled(self.screenshotLabel.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation))
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)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self._create_components()
self._place_components()
self._create_controller()
self.setWindowTitle("Job Crawler")
def _create_components(self):
self.site_gb = QGroupBox(u"Choix des sites")
self.param_gb = QGroupBox(u"Autres Paramètres")
self.search_gb = QGroupBox(u"Mots-clé")
self.log_gb = QGroupBox(u"Logs")
self.apec_cb = QCheckBox(u"APEC")
self.apec_cb.setDisabled(True)
self.caoe_cb = QCheckBox(u"CAO Emploi")
self.caoe_cb.setDisabled(True)
self.inde_cb = QCheckBox(u"Indeed")
self.mons_cb = QCheckBox(u"Monster Job")
self.mons_cb.setDisabled(True)
self.pole_cb = QCheckBox(u"Pole Enmploi")
self.pole_cb.setDisabled(True)
self.regi_cb = QCheckBox(u"Région Job")
self.regi_cb.setDisabled(True)
self.search_label = QLabel(u"Mots-clé de recherche")
self.filter_label = QLabel(u"Critère de filtrage")
self.region_label = QLabel(u"Région")
self.daterange_label = QLabel(u"Plage de recherche")
self.search_qle = QLineEdit()
self.filter_qle = QLineEdit()
self.start_button = QPushButton(u"Rechercher")
self.stop_button = QPushButton(u"Stopper")
self.stop_button.setDisabled(True)
self.daterange_sb = QSpinBox()
self.daterange_sb.setMaximum(40)
self.daterange_sb.setProperty("value", 3)
self.daterange_sb.setSuffix(u" Jours")
self.region_cb = QComboBox()
region_list = toolbox.getconfigvalue("STATIC", "regions").split(',')
self.region_cb.addItems(region_list)
self.log_te = QTextEdit()
self.log_te.setReadOnly(True)
self.log_te.setLineWrapMode(QTextEdit.NoWrap)
self.file_menu = QMenu(u"Fichier")
self.help_menu = QMenu(u"Aide")
def _place_components(self):
site_layout = QHBoxLayout()
temp = QVBoxLayout()
temp.addWidget(self.apec_cb)
temp.addWidget(self.caoe_cb)
temp.addWidget(self.inde_cb)
site_layout.addLayout(temp)
temp = QVBoxLayout()
temp.addWidget(self.mons_cb)
temp.addWidget(self.pole_cb)
temp.addWidget(self.regi_cb)
site_layout.addLayout(temp)
self.site_gb.setLayout(site_layout)
search_layout = QVBoxLayout()
search_layout.addWidget(self.search_label)
search_layout.addWidget(self.search_qle)
search_layout.addWidget(self.filter_label)
search_layout.addWidget(self.filter_qle)
self.search_gb.setLayout(search_layout)
param_layout = QVBoxLayout()
param_layout.addWidget(self.daterange_label)
param_layout.addWidget(self.daterange_sb)
param_layout.addWidget(self.region_label)
param_layout.addWidget(self.region_cb)
self.param_gb.setLayout(param_layout)
log_layout = QVBoxLayout()
log_layout.addWidget(self.log_te)
self.log_gb.setLayout(log_layout)
command_layout = QHBoxLayout()
command_layout.addWidget(self.start_button)
command_layout.addWidget(self.stop_button)
main_layout = QVBoxLayout()
main_layout.addWidget(self.site_gb)
main_layout.addWidget(self.search_gb)
main_layout.addWidget(self.param_gb)
main_layout.addWidget(self.log_gb)
main_layout.addLayout(command_layout)
centralwidget = QWidget(self)
centralwidget.setLayout(main_layout)
self.setCentralWidget(centralwidget)
menubar = self.menuBar()
menubar.addMenu(self.file_menu)
menubar.addMenu(self.help_menu)
def _create_controller(self):
adminAction = QAction(u'Administration', self)
adminAction.setStatusTip(u'Régler les paramètres de l\'application')
adminAction.triggered.connect(self.admin)
exitAction = QAction(u'Quitter', self)
exitAction.setStatusTip(u'Quitter Job Crawler')
exitAction.triggered.connect(qApp.quit)
aboutAction = QAction(u'A propos', self)
aboutAction.setStatusTip(u'Afficher la fenêtre à propos')
aboutAction.triggered.connect(self.about)
self.file_menu.addAction(adminAction)
self.file_menu.addSeparator()
self.file_menu.addAction(exitAction)
self.help_menu.addAction(aboutAction)
self.start_button.clicked.connect(self.start)
self.stop_button.clicked.connect(self.stop)
# Controller for logging
XStream.stdout().messageWritten.connect( self.log_te.insertPlainText )
XStream.stderr().messageWritten.connect( self.log_te.insertPlainText )
def validate_fields(self):
error = False
error_list = u""
inde = self.inde_cb.isChecked()
apec = self.apec_cb.isChecked()
caoe = self.caoe_cb.isChecked()
mons = self.mons_cb.isChecked()
pole = self.pole_cb.isChecked()
regi = self.regi_cb.isChecked()
if not (inde or apec or caoe or mons or pole or regi):
error = True
error_list += u"<li>Site à requêter</li>"
searchkeyword = unidecode(unicode(self.search_qle.text()))
if searchkeyword == u"":
error = True
error_list += u"<li>Mots clé de recherche</li>"
filterkeyword = unidecode(unicode(self.filter_qle.text()))
if filterkeyword == u"":
error = True
error_list += u"<li>Critère de filtrage</li>"
if error:
message = u"Veuillez renseigner le(s) champ(s) suivant(s) :<ul>" + error_list + u"</ul>"
QMessageBox.warning(self, u"Erreur", message)
return not error
def validate_admin(self):
dbpath = toolbox.getconfigvalue("GENERAL", "dbfile")
if not (dbpath != "" and os.access(os.path.dirname(dbpath), os.W_OK)):
message = u"<p>Veuiller renseigner l'emplacement de la base de données dans l'administration (Fichier > Administration).</p>"\
u"<p>Si cela a déjà été fait, ce message signifie que vous n'avez pas les droits d'écriture dans ce répertoire. Veuillez déplacer la base de données et reconfigurer l'emplacement dans l'administration.</p>"
QMessageBox.warning(self, u"Erreur", message)
return False
return True
@pyqtSlot()
def start(self):
def run():
self.start_button.setDisabled(True)
# self.stop_button.setEnabled(True)
logger.info(u"Début")
inde = self.inde_cb.isChecked()
apec = self.apec_cb.isChecked()
caoe = self.caoe_cb.isChecked()
mons = self.mons_cb.isChecked()
pole = self.pole_cb.isChecked()
regi = self.regi_cb.isChecked()
searchkeyword = unidecode(unicode(self.search_qle.text())).split(",")
filterkeyword = unidecode(unicode(self.filter_qle.text())).split(",")
daterange = self.daterange_sb.value()
region = str(self.region_cb.currentText())
dbpath = toolbox.getconfigvalue("GENERAL", "dbfile")
excludelist = unidecode(toolbox.getconfigvalue("GENERAL", "excludes")).split(",")
c = core.core(dbpath)
logger.info(u"Recherche d'annonces")
c.found_annonce(searchkeyword, daterange, region, None, apec, caoe, inde, mons, pole, regi)
logger.info(u"Tri des annonces par rapport aux mots-clé d'exclusion")
c.exclude_annouces(excludelist)
logger.info(u"Tri des annonces par rapport aux critères de filtrage")
c.filter_announces(filterkeyword)
logger.info(u"Fin")
# self.stop_button.setDisabled(True)
self.start_button.setEnabled(True)
if self.validate_fields() and self.validate_admin():
self.thread = threading.Thread(target=run)
self.thread.start()
@pyqtSlot()
def stop(self):
self.thread._Thread__stop()
self.stop_button.setDisabled(True)
self.start_button.setEnabled(True)
@pyqtSlot()
def about(self):
self.aboutwindow = aboutdialog.AboutDialog(self).exec_()
@pyqtSlot()
def admin(self):
admindialog.AdminDialog(self).exec_()
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)
class CANMonitor(QMainWindow):
def __init__(self, app, test, parent):
QMainWindow.__init__(self, parent)
self.app = app
self.lcdDict=dict()
self.logBuffer=deque("", 1000)
self.logBuffer2=dict()
self.logBufferInit=dict()
self.logEntryCount=1
self.maxLogEntryCount=65353
self.tableUpdateCouter=0
self.logFile=None
self.test=test
self.logFileName="/tmp/candash.log"
self.connectCANEnable=True
self.connectGPSEnable=True
self.replayMode=False
self.canIdList=[0x621, 0x353, 0x351, 0x635, 0x271, 0x371, 0x623, 0x571, 0x3e5, 0x591, 0x5d1]
self.updateGPSThread=None
self.config=Config("candash.cfg")
self.log=Log(False)
font = self.font()
font.setPointSize(14)
self.setFont(font)
self.ampelGruen=QIcon("images/ampel-gruen.png")
self.ampelRot=QIcon("images/ampel-rot.png")
self.ampelGelb=QIcon("images/ampel-gelb.png")
self.lastCANState=canStoppedState
self.lastGPSState=gpsStoppedState
self.canDecoder=CANDecoder(self)
self.initUI(parent)
def clearAllLCD(self):
for lcdList in self.lcdDict.values():
for lcd in lcdList:
if lcd.mode()==QLCDNumber.Bin:
lcd.display("00000000")
else:
lcd.display(0)
self.rpmGauge.setValue(0)
self.velGauge.setValue(0)
def createLCD(self, mode):
lcd = QLCDNumber(self)
lcd.setMode(mode)
lcd.setMinimumHeight(50)
lcd.setMinimumWidth(160)
lcd.setDigitCount(8)
if mode==QLCDNumber.Bin:
lcd.display("00000000")
else:
lcd.display(0)
lcd.setSegmentStyle(QLCDNumber.Flat)
lcd.setAutoFillBackground(True)
palette = lcd.palette()
palette.setColor(QPalette.Normal, QPalette.Foreground, Qt.blue)
palette.setColor(QPalette.Normal, QPalette.Background, Qt.lightGray)
lcd.setPalette(palette);
return lcd
def addLCD(self, lcd, canId, subItem):
if not hex(canId)+":"+subItem in self.lcdDict.keys():
lcdItemList=list()
lcdItemList.append(lcd)
self.lcdDict[hex(canId)+":"+subItem]=lcdItemList
else:
self.lcdDict[hex(canId)+":"+subItem].append(lcd)
def createCANIdValueEntry(self, vbox, canId, subId, mode):
lcd = self.createLCD(mode)
self.addLCD(lcd, canId, subId)
vbox.addWidget(lcd)
def createCANIdEntry(self, form, canId, subId, label, mode):
# hbox = QHBoxLayout()
lbl = QLabel(self)
lbl.setMinimumHeight(50)
font = lbl.font()
font.setPointSize(14)
lbl.setFont(font)
if label!=None:
lbl.setText(label)
# hbox.addWidget(lbl)
lcd = self.createLCD(mode)
# hbox.addWidget(lcd)
form.addRow(lbl, lcd)
self.addLCD(lcd, canId, subId)
# vbox.addLayout(hbox)
def createCANIdEntrySingleLine(self, form, canId, subIdList, label, mode):
# hbox = QHBoxLayout()
lbl = QLabel(self)
lbl.setMinimumHeight(50)
font = lbl.font()
font.setPointSize(14)
lbl.setFont(font)
if label!=None:
lbl.setText(label)
# hbox.addWidget(lbl)
hbox2=QHBoxLayout();
for i in range(len(subIdList)):
subId=subIdList[i]
lcd = self.createLCD(mode)
hbox2.addWidget(lcd)
self.addLCD(lcd, canId, subId)
form.addRow(lbl, hbox2)
# hbox.addLayout(hbox2)
# vbox.addLayout(hbox)
def createLogView(self, vbox):
self.logView=QTableView(self)
vbox.addWidget(self.logView)
self.logViewModel=CANLogViewTableModel(self.logBuffer, self.canIdList, self)
self.logView.setModel(self.logViewModel)
header=QHeaderView(Qt.Horizontal, self.logView)
header.setStretchLastSection(True)
header.setResizeMode(NUMBER_COL, QHeaderView.Fixed)
header.setResizeMode(TIME_COL, QHeaderView.Fixed)
header.setResizeMode(ID_COL, QHeaderView.Fixed)
self.logView.setHorizontalHeader(header)
self.logView.setColumnWidth(NUMBER_COL, 80)
self.logView.setColumnWidth(TIME_COL, 150)
self.logView.setColumnWidth(ID_COL, 80)
self.logView.setColumnWidth(SIZE_COL, 50)
def createLogView2(self, vbox):
self.logView2=QTableView(self)
vbox.addWidget(self.logView2)
self.logViewModel2=CANLogViewTableModel2(self.canIdList, self)
self.logView2.setModel(self.logViewModel2)
# self.logView2.setSortingEnabled(True)
header=QHeaderView(Qt.Horizontal, self.logView2)
# header.setStretchLastSection(True)
# header.setClickable(True)
header.setResizeMode(0, QHeaderView.Fixed)
header.setResizeMode(1, QHeaderView.Fixed)
self.logView2.setHorizontalHeader(header)
self.logView2.setColumnWidth(0, 80)
self.logView2.setColumnWidth(1, 50)
for i in range(2, 10):
self.logView2.setColumnWidth(i, 60)
def initUI(self, parent):
# exitAction = QAction(QIcon(), 'Exit', self)
# exitAction.setShortcut('Ctrl+Q')
# exitAction.setStatusTip('Exit application')
# exitAction.triggered.connectToCAN(self.close)
self.statusbar=self.statusBar()
self.progress=QProgressBar()
self.statusbar.addPermanentWidget(self.progress)
# menubar = self.menuBar()
# fileMenu = menubar.addMenu('&File')
# fileMenu.addAction(exitAction)
# toolbar = self.addToolBar('Exit')
## toolbar.addAction(exitAction)
#
# self.connectedIcon=QIcon("images/network-connect.png")
# self.disconnectIcon=QIcon("images/network-disconnect.png")
# self.connectAction = QAction(self.disconnectIcon , 'Connect', self)
# self.connectAction.triggered.connect(self._connect1)
# self.connectAction.setCheckable(True)
#
# toolbar.addAction(self.connectAction)
#
# self.gpsIcon=QIcon("images/icon_gps.gif")
# self.reconnectGPSAction = QAction(self.gpsIcon, 'Reconnect GPS', self)
# self.reconnectGPSAction.triggered.connect(self._reconnectGPS)
# toolbar.addAction(self.reconnectGPSAction)
mainWidget=QWidget(self)
# mainWidget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
mainWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setCentralWidget(mainWidget)
top=QVBoxLayout(mainWidget)
self.tabs = MyTabWidget(self)
top.addWidget(self.tabs)
mainTab = QWidget(self)
miscTab = QWidget(self)
misc2Tab=QWidget(self)
canLogTab=QWidget(self)
dashTab=QWidget(self)
gpsTab=QWidget(self)
osmTab=QWidget(self)
debugLogTab=QWidget(self)
mainTabLayout = QFormLayout(mainTab)
miscTabLayout = QFormLayout(miscTab)
misc2TabLayout = QFormLayout(misc2Tab)
canLogTabLayout = QVBoxLayout(canLogTab)
dashTabLayout = QHBoxLayout(dashTab)
gpsTabLayout=QHBoxLayout(gpsTab)
osmTabLayout=QVBoxLayout(osmTab)
debugLogTabLayout=QVBoxLayout(debugLogTab)
self.tabs.addTab(dashTab, "Dash")
self.tabs.addTab(mainTab, "Main")
self.tabs.addTab(miscTab, "Misc 1")
self.tabs.addTab(misc2Tab, "Misc 2")
self.tabs.addTab(canLogTab, "CAN")
self.tabs.addTab(gpsTab, "GPS")
self.tabs.addTab(osmTab, "OSM")
self.tabs.addTab(debugLogTab, "Log")
self.tabs.setCurrentIndex(0)
self.debugLogWidget=DebugLogWidget(self)
debugLogTabLayout.setAlignment(Qt.AlignLeft|Qt.AlignTop)
self.debugLogWidget.addToWidget(debugLogTabLayout)
# self.debugLogWidget.addLine("test")
self.createCANIdEntry(mainTabLayout, 0x353, "0", "Drehzahl", QLCDNumber.Dec)
# self.createCANIdEntry(mainTabLayout, 0x353, "1", "Öltemperatur", QLCDNumber.Dec)
self.createCANIdEntry(mainTabLayout, 0x353, "1", "Kuehlwasser Temperatur", QLCDNumber.Dec)
self.createCANIdEntry(mainTabLayout, 0x351, "0", "Geschwindigkeit", QLCDNumber.Dec)
self.createCANIdEntry(mainTabLayout, 0x351, "1", "Außentemperatur", QLCDNumber.Dec)
self.createCANIdEntry(miscTabLayout, 0x635, "0", "Licht, Klemme 58d", QLCDNumber.Dec)
self.createCANIdEntry(miscTabLayout, 0x271, "0", "Zuendung", QLCDNumber.Dec)
self.createCANIdEntrySingleLine(miscTabLayout, 0x371, ["0", "1"], "Tuerstatus", QLCDNumber.Bin)
self.createCANIdEntry(miscTabLayout, 0x371, "2", "Blinker, Retoursgang", QLCDNumber.Bin)
self.createCANIdEntrySingleLine(mainTabLayout, 0x623, ["0", "1", "2"], "Uhrzeit (Stunden)", QLCDNumber.Dec)
self.createCANIdEntry(mainTabLayout, 0x571, "0", "Batteriespannung", QLCDNumber.Dec)
self.createCANIdEntry(misc2TabLayout, 0x3e5, "0", "Zuheizer 1", QLCDNumber.Bin)
self.createCANIdEntry(misc2TabLayout, 0x3e5, "1", "Zuheizer 2", QLCDNumber.Bin)
self.createCANIdEntry(misc2TabLayout, 0x3e5, "2", "Zuheizer 3", QLCDNumber.Bin)
self.createCANIdEntry(misc2TabLayout, 0x3e5, "3", "Zuheizer 4", QLCDNumber.Bin)
self.createCANIdEntry(misc2TabLayout, 0x3e5, "4", "Zuheizer 5", QLCDNumber.Bin)
self.createCANIdEntry(miscTabLayout, 0x3e5, "5", "Zuheizer", QLCDNumber.Dec)
self.createCANIdEntry(miscTabLayout, 0x591, "0", "ZV", QLCDNumber.Dec)
self.createCANIdEntry(miscTabLayout, 0x5d1, "0", "Scheibenwischer", QLCDNumber.Dec)
self.createCANIdEntrySingleLine(mainTabLayout, 0x351, ["2", "3"], "Wegstreckenimpuls", QLCDNumber.Dec)
self.createCANIdEntrySingleLine(misc2TabLayout, 0x621, ["0"], "0x621", QLCDNumber.Bin)
self.createCANIdEntrySingleLine(misc2TabLayout, 0x621, ["1", "2"], "0x621", QLCDNumber.Dec)
logTabs = MyTabWidget(self)
canLogTabLayout.addWidget(logTabs)
logTabWidget1=QWidget()
logTabWidget2=QWidget()
logTabs.addTab(logTabWidget1, "Time")
logTabs.addTab(logTabWidget2, "Change")
logTab1Layout = QVBoxLayout(logTabWidget1)
self.createLogView(logTab1Layout)
self.logViewFilerBox1=CANFilterBox(False, self)
self.logViewFilerBox1.addFilterBox(logTab1Layout)
self.logViewTableBox1=CANLogTableBox(self.logViewModel, self.logBuffer, None, self)
self.logViewTableBox1.addTableBox(logTab1Layout)
logTab2Layout = QVBoxLayout(logTabWidget2)
self.createLogView2(logTab2Layout)
self.logViewFilterBox2=CANFilterBox(True, self)
self.logViewFilterBox2.addFilterBox(logTab2Layout)
self.logViewTableBox2=CANLogTableBox(self.logViewModel2, self.logBuffer2, self.logBufferInit, self)
self.logViewTableBox2.addTableBox(logTab2Layout)
logButtonBox = QHBoxLayout()
canLogTabLayout.addLayout(logButtonBox)
self.logFileButton=QCheckBox("Log to File", self)
self.logFileButton.setToolTip('Enable file logging')
self.logFileButton.resize(self.logFileButton.sizeHint())
self.logFileButton.setDisabled(self.replayMode==True)
self.logFileButton.clicked.connect(self._enableLogFile)
logButtonBox.addWidget(self.logFileButton)
self.clearLogButton = QPushButton('Clear Log', self)
self.clearLogButton.resize(self.clearLogButton.sizeHint())
self.clearLogButton.setDisabled(not self.logFileAvailable() or self.replayMode==True)
self.clearLogButton.clicked.connect(self._clearLogFile)
logButtonBox.addWidget(self.clearLogButton)
self.replayButton = QPushButton('Replay Log', self)
self.replayButton.resize(self.replayButton.sizeHint())
self.replayButton.setDisabled(not self.logFileAvailable() or self.connectCANEnable==True)
self.replayButton.clicked.connect(self._startReplayMode)
logButtonBox.addWidget(self.replayButton)
self.stopReplayButton = QPushButton('Stop Replay', self)
self.stopReplayButton.resize(self.stopReplayButton.sizeHint())
self.stopReplayButton.setDisabled(self.replayMode==False)
self.stopReplayButton.clicked.connect(self._stopReplayMode)
logButtonBox.addWidget(self.stopReplayButton)
velBox = QVBoxLayout()
dashTabLayout.addLayout(velBox)
dashTabLayout.setAlignment(Qt.AlignCenter|Qt.AlignBottom)
self.velGauge=QtPngDialGauge(self, "tacho3", "tacho31.png")
self.velGauge.setMinimum(20)
self.velGauge.setMaximum(220)
self.velGauge.setStartAngle(135)
self.velGauge.setValue(0)
# self.velGauge.setMaximumSize(400, 400)
velBox.addWidget(self.velGauge)
self.createCANIdValueEntry(velBox, 0x351, "0", QLCDNumber.Dec)
valuesBox = QVBoxLayout()
valuesBox.setAlignment(Qt.AlignCenter|Qt.AlignBottom)
dashTabLayout.addLayout(valuesBox)
self.createCANIdValueEntry(valuesBox, 0x353, "1", QLCDNumber.Dec)
self.createCANIdValueEntry(valuesBox, 0x351, "1", QLCDNumber.Dec)
self.createCANIdValueEntry(valuesBox, 0x571, "0", QLCDNumber.Dec)
rpmBox = QVBoxLayout()
dashTabLayout.addLayout(rpmBox)
# rpmBox.setAlignment(Qt.AlignCenter|Qt.AlignHCenter)
self.rpmGauge=QtPngDialGauge(self, "rpm", "rpm1.png")
self.rpmGauge.setMinimum(0)
self.rpmGauge.setMaximum(8000)
self.rpmGauge.setStartAngle(125)
self.rpmGauge.setValue(2500)
# self.rpmGauge.setMaximumSize(400, 400)
rpmBox.addWidget(self.rpmGauge)
self.createCANIdValueEntry(rpmBox, 0x353, "0", QLCDNumber.Dec)
self.gpsBox=GPSMonitor(self)
gpsTabLayout.setAlignment(Qt.AlignLeft|Qt.AlignTop)
self.gpsBox.loadConfig(self.config)
self.gpsBox.addToWidget(gpsTabLayout)
self.osmWidget=OSMWidget(self)
osmTabLayout.setAlignment(Qt.AlignLeft|Qt.AlignTop)
self.osmWidget.addToWidget(osmTabLayout)
self.osmWidget.loadConfig(self.config)
self.osmWidget.initWorkers()
self.connect(self.osmWidget.mapWidgetQt, SIGNAL("updateStatus(QString)"), self.updateStatusBarLabel)
self.connect(self.osmWidget.downloadThread, SIGNAL("updateStatus(QString)"), self.updateStatusBarLabel)
self.connect(self.osmWidget, SIGNAL("updateStatus(QString)"), self.updateStatusBarLabel)
self.connect(self.osmWidget, SIGNAL("startProgress()"), self.startProgress)
self.connect(self.osmWidget, SIGNAL("stopProgress()"), self.stopProgress)
self.osmWidget.initHome()
connectBox=QHBoxLayout()
top.addLayout(connectBox)
section="connect"
self.connectCANButton = QCheckBox('CAN Connect', self)
self.connectCANButton.clicked.connect(self._connectCAN)
self.connectCANEnable=self.config.getSection(section).getboolean("CANconnect", False)
self.connectCANButton.setChecked(self.connectCANEnable)
self.connectCANButton.setIcon(self.ampelRot)
connectBox.addWidget(self.connectCANButton)
self.connectGPSButton = QCheckBox('GPS Connect', self)
self.connectGPSButton.clicked.connect(self._connectGPS)
self.connectGPSEnable=self.config.getSection(section).getboolean("GPSconnect", False)
self.connectGPSButton.setChecked(self.connectGPSEnable)
self.connectGPSButton.setIcon(self.ampelRot)
connectBox.addWidget(self.connectGPSButton)
self.setGeometry(0, 0, 900, 600)
self.setWindowTitle("candash")
self.show()
self.updateCANThread = CANSocketWorker(self)
self.connect(self.updateCANThread, SIGNAL("updateStatus(QString)"), self.updateStatusBarLabel)
self.connect(self.updateCANThread, SIGNAL("updateCANThreadState(QString)"), self.updateCANThreadState)
self.connect(self.updateCANThread, SIGNAL("clearAllLCD()"), self.clearAllLCD)
self.connect(self.updateCANThread, SIGNAL("connectCANFailed()"), self.connectCANFailed)
self.connect(self.updateCANThread, SIGNAL("replayModeDone()"), self.replayModeDone)
self.connect(self.updateCANThread, SIGNAL("processCANData(PyQt_PyObject)"), self.canDecoder.scan_can_frame)
self._connectCAN()
self.updateGPSThread=getGPSUpdateThread(self)
if self.updateGPSThread!=None:
self.connect(self.updateGPSThread, SIGNAL("updateStatus(QString)"), self.updateStatusBarLabel)
self.connect(self.updateGPSThread, SIGNAL("updateGPSThreadState(QString)"), self.updateGPSThreadState)
self.connect(self.updateGPSThread, SIGNAL("connectGPSFailed()"), self.connectGPSFailed)
self.connect(self.updateGPSThread, SIGNAL("updateGPSDisplay(PyQt_PyObject)"), self.updateGPSDisplay)
self._connectGPS()
#def mousePressEvent(self, event):
# print("CANMonitor mousePressEvent")
# self.tabs.mousePressEvent(event)
def getWidget(self, canId, subId):
try:
return self.lcdDict[hex(canId)+":"+subId]
except KeyError:
return list()
def setValueDashDisplayRPM(self, value):
if value!=self.rpmGauge.value():
self.rpmGauge.setValue(value)
def setValueDashDisplayVel(self, value):
if value!=self.velGauge.value():
self.velGauge.setValue(value)
def displayIntValue(self, canId, subId, value, formatString):
lcdList=self.getWidget(canId, subId)
for lcdItem in lcdList:
if lcdItem.intValue()!=int(value):
lcdItem.display(formatString % value)
def displayBinValue(self, canId, subId, value, formatString):
lcdList=self.getWidget(canId, subId)
for lcdItem in lcdList:
if lcdItem.intValue()!=int(value):
lcdItem.display(formatString % value)
def displayFloatValue(self, canId, subId, value, formatString):
lcdList=self.getWidget(canId, subId)
for lcdItem in lcdList:
if lcdItem.value()!=value:
lcdItem.display(formatString % value)
def addToLogView(self, line):
tableEntry=[self.logEntryCount, self.createTimeStamp()]
tableEntry.extend(line[0:])
if self.logFile!=None:
self.addToLogFile(tableEntry)
if self.logViewTableBox1.update==True:
canId=line[0]
if not self.logViewFilerBox1.matchFilter(canId, line, None):
return
self.logBuffer.appendleft(tableEntry)
self.logEntryCount=self.logEntryCount+1
if self.logEntryCount==self.maxLogEntryCount:
self.logEntryCount=1
self.tableUpdateCouter=self.tableUpdateCouter+1
if self.tableUpdateCouter==10:
self.logViewModel.update(self.logBuffer, None)
self.tableUpdateCouter=0
def addToLogView2(self, line):
if self.logViewTableBox2.update==True:
canId=line[0]
if not canId in self.logBufferInit.keys():
self.logBufferInit[canId]=line
if not self.logViewFilterBox2.matchFilter(canId, line, self.logBufferInit[canId]):
try:
del self.logBuffer2[canId]
except KeyError:
None
else:
self.logBuffer2[canId]=line
self.logViewModel2.update(list(self.logBuffer2.values()), self.logBufferInit)
def createTimeStamp(self):
stamp=datetime.fromtimestamp(time.time())
return "".join(["%02d:%02d:%02d.%06d"%(stamp.hour, stamp.minute, stamp.second, stamp.microsecond)])
def dumpLogLine(self, line):
logLine="%s %s %s"% (line[1], hex(line[2]), line[3])
dataLine="".join(["0x%02X " % x for x in line[4]])
return logLine+" "+dataLine
def addToLogFile(self, line):
if self.logFile!=None:
self.logFile.write(self.dumpLogLine(line)+"\n")
def setupLogFile(self, filePath):
if self.logFile==None:
self.logFile=open(filePath,"a")
self.logFile.write("# Log started: "+time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())+"\n")
self.logFile.write("# -------------------------------------------------------\n")
def closeLogFile(self):
if self.logFile!=None:
self.logFile.write("# Log stoped: "+time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())+"\n")
self.logFile.write("# -------------------------------------------------------\n")
self.logFile.close()
self.logFile=None
def logFileAvailable(self):
try:
open(self.logFileName, "r")
return True
except IOError:
return False
def readLogFile(self):
try:
logFileEntries=list()
readLogFile=open(self.logFileName, "r")
while True:
line=readLogFile.readline()
if not line:
break
if line[0]=="#":
continue
lineParts=line.split(" ")
strippedLen=len(lineParts)-1
neededLineParts=lineParts[1:strippedLen]
addLen=8-len(neededLineParts[2:])
for _ in range(addLen):
neededLineParts.append("%s" % "0x00")
logFileEntries.append(struct.pack("IIBBBBBBBB", int(neededLineParts[0], 16), int(neededLineParts[1], 10), int(neededLineParts[2], 16),
int(neededLineParts[3], 16),int(neededLineParts[4], 16),int(neededLineParts[5], 16),int(neededLineParts[6], 16),
int(neededLineParts[7], 16), int(neededLineParts[8], 16), int(neededLineParts[9], 16)))
return logFileEntries
except IOError:
return list()
@pyqtSlot()
def _enableFilter(self):
self.filter=self.filterButton.isChecked()
self.filterEdit.setDisabled(self.filter==False)
self.applyFilterButton.setDisabled(self.filter==False)
self.filterAll.setDisabled(self.filter==False)
self.filterKnown.setDisabled(self.filter==False)
self.filterUnknown.setDisabled(self.filter==False)
self.filterRingIdsButton.setDisabled(self.filter==False)
@pyqtSlot()
def _applyFilter(self):
if self.filter==True:
self.filterValue=self.filterEdit.text()
else:
self.filterValue=""
@pyqtSlot()
def _cleanup(self):
self.osmWidget._cleanup()
self.gpsBox._cleanup()
if self.updateCANThread.isRunning():
self.updateCANThread.stop()
if self.updateGPSThread.isRunning():
self.updateGPSThread.stop()
self.closeLogFile()
section="connect"
self.config.removeSection(section)
self.config.addSection(section)
self.config.getSection(section)["canConnect"]=str(self.connectCANEnable)
self.config.getSection(section)["gpsConnect"]=str(self.connectGPSEnable)
self.osmWidget.saveConfig(self.config)
self.gpsBox.saveConfig(self.config)
self.config.writeConfig()
self.log.writeLogtoFile()
@pyqtSlot()
def _enableLogFile(self):
if self.logFileButton.isChecked()==True:
if self.logFile==None:
self.setupLogFile(self.logFileName)
else:
self.closeLogFile()
self.replayButton.setDisabled(not self.logFileAvailable() or self.connectCANEnable==True)
self.clearLogButton.setDisabled(not self.logFileAvailable() or self.replayMode==True)
@pyqtSlot()
def _startReplayMode(self):
self.closeLogFile()
self.logFileButton.setChecked(False)
self.replayButton.setDisabled(True)
self.replayMode=True
self.stopReplayButton.setDisabled(self.replayMode==False)
self.logFileButton.setDisabled(self.replayMode==True)
self.clearLogButton.setDisabled(not self.logFileAvailable() or self.replayMode==True)
replayLines=self.readLogFile()
self.logViewTableBox1._clearTable()
self.logViewTableBox2._clearTable()
self.updateCANThread.setup(self.app, self, self.test, True, replayLines)
@pyqtSlot()
def _stopReplayMode(self):
self.updateCANThread.stop()
self.replayModeDone()
def replayModeDone(self):
self.replayMode=False
self.stopReplayButton.setDisabled(self.replayMode==False)
self.replayButton.setDisabled(not self.logFileAvailable() or self.connectCANEnable==True)
self.logFileButton.setDisabled(self.replayMode==True)
self.clearLogButton.setDisabled(not self.logFileAvailable() or self.replayMode==True)
@pyqtSlot()
def _clearLogFile(self):
if self.logFileAvailable():
self.closeLogFile()
os.remove(self.logFileName)
self.logFile=None
self._enableLogFile()
@pyqtSlot()
def _connectCAN(self):
self.connectCANEnable=self.connectCANButton.isChecked()
if self.replayMode==True:
self._stopReplayMode()
if self.connectCANEnable==True:
# self.connectCANButton.setDisabled(True)
self.logViewTableBox1._clearTable()
self.logViewTableBox2._clearTable()
self.updateCANThread.setup(self.app, self.connectCANEnable, self.test, False, None)
else:
if self.updateCANThread.isRunning():
# self.connectCANButton.setDisabled(True)
self.updateCANThread.stop()
self.replayButton.setDisabled(not self.logFileAvailable() or self.connectCANEnable==True)
self.connectCANButton.setChecked(self.connectCANEnable==True)
@pyqtSlot()
def _connectGPS(self):
self.connectGPSEnable=self.connectGPSButton.isChecked()
if self.connectGPSEnable==True:
# self.connectGPSButton.setDisabled(True)
self.updateGPSThread.setup(self.connectGPSEnable)
else:
if self.updateGPSThread.isRunning():
# self.connectGPSButton.setDisabled(True)
self.updateGPSThread.stop()
self.connectGPSButton.setChecked(self.connectGPSEnable==True)
@pyqtSlot()
def _enableFilterRingIds(self):
self.filterRingIds=self.filterRingIdsButton.isChecked()
def connectCANEnabled(self):
return self.connectCANEnable
def connectCANFailed(self):
self.connectCANEnable=False
self.connectCANButton.setChecked(False)
# self.connectCANButton.setDisabled(False)
self.connectCANButton.setIcon(self.ampelRot)
def updateStatusBarLabel(self, text):
self.statusbar.showMessage(text)
logLine=self.log.addLineToLog(text)
self.debugLogWidget.addLineToLog(logLine)
def stopProgress(self):
self.progress.setMinimum(0)
self.progress.setMaximum(1)
self.progress.reset()
def startProgress(self):
self.progress.setMinimum(0)
self.progress.setMaximum(0)
# def connectCANSuccessful(self):
# self.connectCANEnable=True
## self.connectCANButton.setChecked(True)
## self.connectCANButton.setDisabled(False)
# self.connectCANButton.setIcon(self.ampelGruen)
# def stopCANSuccesful(self):
# self.connectCANButton.setDisabled(False)
# self.connectCANButton.setIcon(self.ampelRot)
def canIdIsInKnownList(self, canId):
return canId in self.canIdList
def updateGPSDisplay(self, gpsData):
self.gpsBox.update(gpsData)
def showError(self, title, text):
msgBox=QMessageBox(QMessageBox.Warning, title, text, QMessageBox.Ok, self)
font = self.font()
font.setPointSize(14)
msgBox.setFont(font)
msgBox.exec()
def connectGPSFailed(self):
self.connectGPSButton.setChecked(False)
self.connectGPSEnable=False
# self.connectGPSButton.setDisabled(False)
self.connectGPSButton.setIcon(self.ampelRot)
self.showError("GPS Error", "Error connecing to GPS")
# def connectGPSSuccesful(self):
## self.connectGPSButton.setChecked(True)
# self.connectGPSEnable=True
## self.connectGPSButton.setDisabled(False)
# self.connectGPSButton.setIcon(self.ampelGruen)
def connectGPSEnabled(self):
return self.connectGPSEnable
# def stopGPSSuccesful(self):
# self.connectGPSButton.setDisabled(False)
# self.connectGPSButton.setIcon(self.ampelRot)
def updateCANThreadState(self, state):
if state!=self.lastCANState:
if state==canIdleState:
self.connectCANButton.setIcon(self.ampelGelb)
elif state==canRunState:
self.connectCANButton.setIcon(self.ampelGruen)
elif state==canStoppedState:
self.connectCANButton.setIcon(self.ampelRot)
self.connectCANEnable=False
self.lastCANState=state
def updateGPSThreadState(self, state):
if state!=self.lastGPSState:
if state==gpsRunState:
self.connectGPSButton.setIcon(self.ampelGruen)
elif state==gpsStoppedState:
self.connectGPSButton.setIcon(self.ampelRot)
self.connectGPSnable=False
self.lastGPSState=state
def hasOSMWidget(self):
return self.osmWidget!=None
class CANFilterBox(QWidget):
def __init__(self, withChanged, parent):
QWidget.__init__(self, parent)
self.canMonitor=parent
self.filter=False
self.filterValue=""
self.filterRingIds=False
self.withChanged=withChanged
self.filterChanged=False
def addFilterBox(self, layout):
hbox = QHBoxLayout()
layout.addLayout(hbox)
# hbox.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.filterButton=QCheckBox("Filter", self.canMonitor)
self.filterButton.setToolTip('Enable filter')
self.filterButton.resize(self.filterButton.sizeHint())
self.filterButton.clicked.connect(self._enableFilter)
hbox.addWidget(self.filterButton)
self.filterEdit=QLineEdit(self.canMonitor)
self.filterEdit.setToolTip('Id Filter')
self.filterEdit.setDisabled(self.filter==False)
self.filterEdit.returnPressed.connect(self._applyFilter)
hbox.addWidget(self.filterEdit)
self.applyFilterButton = QPushButton('Apply', self.canMonitor)
self.applyFilterButton.setToolTip('Use Id filter')
self.applyFilterButton.resize(self.applyFilterButton.sizeHint())
self.applyFilterButton.clicked.connect(self._applyFilter)
self.applyFilterButton.setDisabled(self.filter==False)
hbox.addWidget(self.applyFilterButton)
self.filterKnown=QRadioButton("Known", self.canMonitor)
self.filterKnown.clicked.connect(self._applyFilter)
self.filterKnown.setDisabled(self.filter==False)
hbox.addWidget(self.filterKnown)
self.filterUnknown=QRadioButton("Unknown", self.canMonitor)
self.filterUnknown.clicked.connect(self._applyFilter)
self.filterUnknown.setDisabled(self.filter==False)
hbox.addWidget(self.filterUnknown)
self.filterAll=QRadioButton("All", self.canMonitor)
self.filterAll.clicked.connect(self._applyFilter)
self.filterAll.setDisabled(self.filter==False)
self.filterAll.setChecked(True)
hbox.addWidget(self.filterAll)
self.filterRingIdsButton=QCheckBox("Ring Ids", self.canMonitor)
self.filterRingIdsButton.resize(self.filterRingIdsButton.sizeHint())
self.filterRingIdsButton.clicked.connect(self._enableFilterRingIds)
self.filterRingIdsButton.setDisabled(self.filter==False)
self.filterRingIdsButton.setChecked(self.filterRingIds)
hbox.addWidget(self.filterRingIdsButton)
if self.withChanged==True:
self.filterChangedButton=QCheckBox("Changed", self.canMonitor)
self.filterChangedButton.resize(self.filterChangedButton.sizeHint())
self.filterChangedButton.clicked.connect(self._enableFilterChanged)
self.filterChangedButton.setDisabled(self.filter==False)
self.filterChangedButton.setChecked(self.filterChanged)
hbox.addWidget(self.filterChangedButton)
def matchFilter(self, canId, line, lineInit):
if self.filter==True:
idMatch=self.matchIdFilter(canId)
if idMatch==False:
return False
changedMatched=self.matchChangedFilter(line, lineInit)
if changedMatched==False:
return False
if self.filterAll.isChecked():
return idMatch
isKnownId=self.canMonitor.canIdIsInKnownList(canId)
if self.filterKnown.isChecked():
return isKnownId==False
if self.filterUnknown.isChecked():
return isKnownId==True
return True
def matchIdFilter(self, canId):
if self.filter==True:
# filter ring ids
if self.filterRingIds==True:
if canId>=0x400 and canId <=0x43F:
return False
if len(self.filterValue)!=0:
if not fnmatch.fnmatch(hex(canId), self.filterValue):
return False
return True
def matchChangedFilter(self, line, lineInit):
if self.filter==True:
if self.filterChanged==True:
if line!=lineInit:
return True
return False
return True
@pyqtSlot()
def _applyFilter(self):
if self.filter==True:
self.filterValue=self.filterEdit.text()
else:
self.filterValue=""
@pyqtSlot()
def _enableFilter(self):
self.filter=self.filterButton.isChecked()
self.filterEdit.setDisabled(self.filter==False)
self.applyFilterButton.setDisabled(self.filter==False)
self.filterAll.setDisabled(self.filter==False)
self.filterKnown.setDisabled(self.filter==False)
self.filterUnknown.setDisabled(self.filter==False)
self.filterRingIdsButton.setDisabled(self.filter==False)
if self.withChanged==True:
self.filterChangedButton.setDisabled(self.filter==False)
@pyqtSlot()
def _enableFilterRingIds(self):
self.filterRingIds=self.filterRingIdsButton.isChecked()
@pyqtSlot()
def _enableFilterChanged(self):
self.filterChanged=self.filterChangedButton.isChecked()
