def __init__(self, foldable_data, parent=None):
QWidget.__init__(self, parent)
self.foldable = False
#Contained widgets
self.fold_button = FoldButton()
self.noop_button = NoopButton()
self.name = QLabel()
self.abstract = foldable_data.abstract
self.edit_button = EditButton()
#Layout
box = QHBoxLayout(self)
box.setMargin(0)
box.setAlignment(Qt.AlignLeft)
box.addWidget(self.fold_button)
box.addWidget(self.noop_button)
box.addWidget(self.name)
box.addWidget(self.abstract)
box.addStretch()
box.addWidget(self.edit_button)
self.setFoldable(True)
#SIGNALS to update content
self.connect(foldable_data, SIGNAL('name changed'), self.setName)
self.connect(foldable_data, SIGNAL('menu changed'), self.setMenu)
#Initialize content
self.setName(foldable_data.name)
self.setMenu(foldable_data.menu)
class StatusWidget(QWidget):
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
self.setSizePolicy(sizePolicy)
self.__hlayout = QHBoxLayout(self)
self.__hlayout.setSpacing(6)
self.__hlayout.setSizeConstraint(QLayout.SetMinimumSize)
self.__hlayout.setMargin(0)
self.__hlayout.setAlignment(Qt.AlignLeft)
self.__labels = []
self.__model = None
def setStatusModel(self, model):
self.__model = model
for idx in xrange(0, model.count()):
label = StatusLabel(self, model.status(idx))
self.__hlayout.addWidget(label)
if idx < model.count() - 1:
line = QFrame(self)
line.setFrameShape(QFrame.VLine)
line.setFrameShadow(QFrame.Sunken)
self.__hlayout.addWidget(line)
self.__labels.append(label)
def __init__(self, model, label="Checkbox", help_link="", show_label=True, alt_label=None, default_check_state=True):
"""Construct a checkbox widget for booleans"""
HelpedWidget.__init__(self, label, help_link)
if show_label:
if alt_label is not None:
self.check = QCheckBox(alt_label, self)
else:
self.check = QCheckBox(label,self)
else:
self.check = QCheckBox(self)
self.check.setTristate(False)
self.check.setChecked(default_check_state)
self.connect(self.check, QtCore.SIGNAL('stateChanged(int)'), self.contentsChanged)
if not show_label:
layout = QHBoxLayout()
layout.addWidget(self.check)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(0, 0, 0, 0)
self.addLayout(layout)
else:
self.addWidget(self.check)
assert isinstance(model, BooleanModelMixin)
self.model = model
self.model.observable().attach(BooleanModelMixin.BOOLEAN_VALUE_CHANGED_EVENT, self.modelChanged)
self.modelChanged()
def _getSpinbox(self, minvalue, maxvalue, step, nullable = True, value = 0):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
spinbox = QDoubleSpinBox()
spinbox.setMinimum(minvalue)
spinbox.setMaximum(maxvalue)
spinbox.setSingleStep(step)
spinbox.setDecimals(len(str(step).split('.')[1]) if len(str(step).split('.'))==2 else 0)
if nullable:
spinbox.setMinimum(minvalue - step)
spinbox.setValue(spinbox.minimum())
spinbox.setSpecialValueText(str(QSettings().value('qgis/nullValue', 'NULL' )))
if value is not None:
spinbox.setValue(value)
layout = QHBoxLayout(widget)
layout.addWidget(spinbox, 1);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(5,0,5,0);
widget.setLayout(layout);
return widget
class AbstractTrackPanel(QWidget):
def __init__(self, tracks, parent):
QWidget.__init__(self,parent)
fixed_size_policy(self)
self.tracks = tracks
self.layout = QHBoxLayout(self)
def animate_tracks(self):
for track in self.tracks:
track.animation_on()
def deanimate_tracks(self):
for track in self.tracks:
track.animation_off()
def set_depth(self, percentage):
for track in self.tracks:
track.set_depth(percentage)
def _setup_depth_slider(self, depth_min, depth_max):
self.depth_slider = DepthSlider(depth_min, depth_max, self)
self.layout.addWidget(self.depth_slider)
self.layout.setAlignment(self.depth_slider, Qt.AlignLeft)
QWidget.connect(self.depth_slider.slider, SIGNAL("valueChanged(int)"),
self.set_depth)
QWidget.connect(self.depth_slider.slider, SIGNAL("sliderPressed()"),
self.animate_tracks)
QWidget.connect(self.depth_slider.slider, SIGNAL("sliderReleased()"),
self.deanimate_tracks)
def _getSpinbox(self, minvalue, maxvalue, step, nullable=True, value=0):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
spinbox = QDoubleSpinBox()
spinbox.setMinimum(minvalue)
spinbox.setMaximum(maxvalue)
spinbox.setSingleStep(step)
spinbox.setDecimals(
len(str(step).split('.')[1]) if len(str(step).split('.')) ==
2 else 0)
if nullable:
spinbox.setMinimum(minvalue - step)
spinbox.setValue(spinbox.minimum())
spinbox.setSpecialValueText(
str(QSettings().value('qgis/nullValue', 'NULL')))
if value is not None:
spinbox.setValue(value)
layout = QHBoxLayout(widget)
layout.addWidget(spinbox, 1)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(5, 0, 5, 0)
widget.setLayout(layout)
return widget
def _getCalendar(self, display_format, value = None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
calendar = QDateTimeEdit()
calendar.setCalendarPopup(True)
calendar.setDisplayFormat(display_format)
if value is not None:
calendar.setDate(QDate.fromString(value, display_format))
else:
calendar.setDate(QDate.currentDate())
layout = QHBoxLayout(widget)
layout.addWidget(calendar, 1);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(5,0,5,0);
widget.setLayout(layout);
return widget
def __init__(self, parent=None, show_fullpath=True, fullpath_sorting=True,
show_all_files=True, show_comments=True):
QWidget.__init__(self, parent)
self.treewidget = OutlineExplorerTreeWidget(self,
show_fullpath=show_fullpath,
fullpath_sorting=fullpath_sorting,
show_all_files=show_all_files,
show_comments=show_comments)
self.visibility_action = create_action(self,
_("Show/hide outline explorer"),
icon='outline_explorer_vis.png',
toggled=self.toggle_visibility)
self.visibility_action.setChecked(True)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignRight)
for btn in self.setup_buttons():
btn_layout.addWidget(btn)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.treewidget)
layout.addLayout(btn_layout)
self.setLayout(layout)
def _getCalendar(self, display_format, value=None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
calendar = QDateTimeEdit()
calendar.setCalendarPopup(True)
calendar.setDisplayFormat(display_format)
if value is not None:
calendar.setDate(QDate.fromString(value, display_format))
else:
calendar.setDate(QDate.currentDate())
layout = QHBoxLayout(widget)
layout.addWidget(calendar, 1)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(5, 0, 5, 0)
widget.setLayout(layout)
return widget
def __init__(self,
parent=None,
show_fullpath=True,
fullpath_sorting=True,
show_all_files=True,
show_comments=True):
QWidget.__init__(self, parent)
self.treewidget = OutlineExplorerTreeWidget(
self,
show_fullpath=show_fullpath,
fullpath_sorting=fullpath_sorting,
show_all_files=show_all_files,
show_comments=show_comments)
self.visibility_action = create_action(self,
_("Show/hide outline explorer"),
icon='outline_explorer_vis.png',
toggled=self.toggle_visibility)
self.visibility_action.setChecked(True)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignRight)
for btn in self.setup_buttons():
btn_layout.addWidget(btn)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.treewidget)
layout.addLayout(btn_layout)
self.setLayout(layout)
class QImageWidget(QWidget):
def __init__(self, parent=None):
super(QImageWidget, self).__init__(parent)
self.layout = QHBoxLayout(self)
self.label = QLabel()
self.layout.addWidget(self.label)
self.pixmap = QPixmap()
self.label.setPixmap(self.pixmap)
self.image = QImage()
self.setContentsMargins(0, 0, 0, 0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setAlignment(Qt.AlignCenter)
def set_opencv_image(self, raw_image):
if raw_image is not None:
self.image = QImage(raw_image, raw_image.shape[1], \
raw_image.shape[0], raw_image.shape[1] * 3,
QImage.Format_RGB888)
self.pixmap = QPixmap(self.image)
self.label.setPixmap(self.pixmap)
def show_on_second_screen(self):
desktop_widget = QApplication.desktop()
if desktop_widget.screenCount() > 1:
second_screen_size = desktop_widget.screenGeometry(1)
self.move(second_screen_size.left(), second_screen_size.top())
self.resize(second_screen_size.width(), second_screen_size.height())
self.showMaximized()
def initUI(self):
style=QCommonStyle()
top=QVBoxLayout()
top.setSpacing(2)
self.tabs = MyTabWidget(self)
top.addWidget(self.tabs)
self.tabManager.addAllTabs(self.tabs)
buttons=QHBoxLayout()
buttons.setAlignment(Qt.AlignBottom|Qt.AlignRight)
self.cancelButton=QPushButton("Cancel", self)
self.cancelButton.clicked.connect(self._cancel)
self.cancelButton.setIcon(style.standardIcon(QStyle.SP_DialogCancelButton))
buttons.addWidget(self.cancelButton)
self.okButton=QPushButton("Ok", self)
self.okButton.clicked.connect(self._ok)
self.okButton.setDefault(True)
self.okButton.setIcon(style.standardIcon(QStyle.SP_DialogOkButton))
buttons.addWidget(self.okButton)
top.addLayout(buttons)
self.setLayout(top)
self.setWindowTitle('Options')
self.setGeometry(0, 0, 400, 500)
def _getShpFieldsCombobox(self, qgisfield, selected_shpfield = None):
'''
Get a combobox filled with the SHP layer fields to insert in a table widget
:param qgisfield: The SHP field
:type qgisfield: QgsField
:param selected_shpfield: The QGIS field to select
:type selected_shpfield: QString, str
:returns: A combobox with the QGIS layer fields
:rtype: QWidget
'''
# Datatype mapping allowed while checking. For a given SHP type, several QGIS type may be allowed or compatible
SHP_QGIS_ALLOWED_DATATYPE_MAP = [(QVariant.String, QVariant.String),
(QVariant.LongLong, QVariant.LongLong),
(QVariant.LongLong, QVariant.Double),
(QVariant.LongLong, QVariant.String),
(QVariant.Int, QVariant.Int),
(QVariant.Int, QVariant.LongLong),
(QVariant.Int, QVariant.Double),
(QVariant.Int, QVariant.String),
(QVariant.Double, QVariant.Double),
(QVariant.Double, QVariant.String)]
widget = QWidget()
combobox = QComboBox()
layout = QHBoxLayout(widget)
layout.addWidget(combobox, 1);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(5,0,5,0);
widget.setLayout(layout);
shplayer = self.shplayer
shplayer_fields = shplayer.dataProvider().fields()
current_item_index = 0
selected_index = 0
combobox.addItem(QCoreApplication.translate('ImportShpDialog','<None>'), None)
current_item_index += 1
for field in shplayer_fields:
# Include only fields with compatible data type
for shp_type, qgis_type in SHP_QGIS_ALLOWED_DATATYPE_MAP:
if field.type() == shp_type and qgisfield.type() == qgis_type:
combobox.addItem(field.name(), field.name())
# Select field if same name
if field.name() == qgisfield.name() and selected_index == 0:
selected_index = current_item_index
if field.name() == selected_shpfield:
selected_index = current_item_index
current_item_index += 1
break;
combobox.setCurrentIndex(selected_index)
combobox.currentIndexChanged.connect(self._comboboxShpFieldIndexChanged)
return widget
def _configurarGui(self):
layout = QHBoxLayout()
layout.setMargin(0)
layout.setAlignment(Qt.AlignCenter)
self._lblIP = QLabel()
layout.addWidget(self._lblIP)
self.setLayout(layout)
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 __init__(self, parent=None):
QWidget.__init__(self)
self.setParent(parent)
layout = QHBoxLayout(self)
self.checkbox = QCheckBox(self)
layout.addWidget(self.checkbox)
layout.setContentsMargins(12, 0, 0, 0) # Hack to correct offset.
layout.setAlignment(Qt.AlignCenter)
self.setLayout(layout)
def __init__(self, parent = None):
QWidget.__init__(self, parent)
self.add = AddButton()
self.rem = RemButton()
layout = QHBoxLayout(self)
layout.setAlignment(Qt.AlignRight)
layout.addStretch()
layout.addWidget(self.add)
layout.addWidget(self.rem)
def add_button(self, id):
widget = QWidget()
fileBtn = QPushButton()
fileBtn.setText(u'浏览...')
fileBtn.clicked.connect(lambda: self.updateTable(id))
hLayout = QHBoxLayout()
hLayout.addWidget(fileBtn)
hLayout.setAlignment(Qt.AlignHCenter)
hLayout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(hLayout)
return widget
def __init__(self, parent=None): #Constructor
super(PromptMenu, self).__init__(parent)
self.setGeometry(550, 450, 600, 300)
self.setWindowTitle("PyMontage Menu")
self.setStyleSheet("QWidget{ background-color: #daf7a6;}")
self.menuLabel = QLabel(self)
self.menuLabel.setText("Welcome to PyMontage")
self.menuLabel.setFont(QFont("Adobe Gothic Std B", 20))
self.menuLabel.setStyleSheet("QLabel{ color: #566573; }")
self.menuLabel.setAlignment(QtCore.Qt.AlignCenter)
self.button1 = QPushButton(
"1. Create montages recursively from given directory and sub-directories",
self)
QPushButtonStyleStr = 'QPushButton{ background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #eafaf1, stop: 1 #d5f5e3); } \
QPushButton:hover{ background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #b4e6ed, stop: 1 #a6e3ec); } \
QPushButton:pressed{ background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #b4e6ed, stop: 1 #60c1dc);}'
self.button1.setStyleSheet(QPushButtonStyleStr)
self.button2 = QPushButton(
"2. Create montages from provided CSV files (split categories or bins)",
self)
self.button2.setStyleSheet(QPushButtonStyleStr)
self.button3 = QPushButton(
"3. Create vertical montage from provided CSV file", self)
self.button3.setStyleSheet(QPushButtonStyleStr)
self.button4 = QPushButton(
"4. Create image histogram from provided CSV file", self)
self.button4.setStyleSheet(QPushButtonStyleStr)
self.exitBtn = QPushButton("Exit", self)
self.exitBtn.setStyleSheet(QPushButtonStyleStr)
self.exitBtn.setFixedWidth(50)
self.layout = QVBoxLayout(self)
self.button1.clicked.connect(self.b1Clicked)
self.button2.clicked.connect(self.b2Clicked)
self.button3.clicked.connect(self.b3Clicked)
self.button4.clicked.connect(self.b4Clicked)
self.exitBtn.clicked.connect(self.close)
layout2 = QHBoxLayout()
self.layout.addWidget(self.menuLabel)
self.layout.addWidget(self.button1)
self.layout.addWidget(self.button2)
self.layout.addWidget(self.button3)
self.layout.addWidget(self.button4)
layout2.addWidget(self.exitBtn)
layout2.setAlignment(self.exitBtn, QtCore.Qt.AlignCenter)
self.layout.addLayout(layout2)
self.montageDir = MontageDir(self)
self.montageFromCSV = MontageFromCSV(self)
self.verticalMontageFromCSV = VerticalMontageFromCSV(self)
self.imageHistFromCSV = ImageHistFromCSV(self)
def addToWidget(self, vbox):
self.text = QPlainTextEdit(self.canMonitor)
self.text.setReadOnly(True)
vbox.addWidget(self.text)
hbox = QHBoxLayout()
hbox.setAlignment(Qt.AlignRight | Qt.AlignBottom)
self.clearButton = QPushButton("Clear", self.canMonitor)
self.clearButton.clicked.connect(self._clearText)
hbox.addWidget(self.clearButton)
vbox.addLayout(hbox)
def insert_single_checkbox(self, qtable):
""" Create one QCheckBox and put into QTableView at position @self.chk_position """
cell_widget = QWidget()
chk = QCheckBox()
lay_out = QHBoxLayout(cell_widget)
lay_out.addWidget(chk)
lay_out.setAlignment(Qt.AlignCenter)
lay_out.setContentsMargins(0, 0, 0, 0)
cell_widget.setLayout(lay_out)
i = qtable.model().index(qtable.model().rowCount() - 1,
self.chk_position)
qtable.setIndexWidget(i, cell_widget)
def initUI(self):
mainWidget = QWidget()
mainWidget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.setCentralWidget(mainWidget)
top = QVBoxLayout(mainWidget)
tabs = QTabWidget(self)
top.addWidget(tabs)
gpsTab = QWidget()
gpsTabLayout = QHBoxLayout(gpsTab)
gpsTabLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
tabs.addTab(gpsTab, "GSM")
self.osmWidget = GPSMonitor(self)
self.osmWidget.loadConfig(self.config)
self.osmWidget.addToWidget(gpsTabLayout)
self.zoom = 9
self.startLat = 47.8
self.startLon = 13.0
self.testGPSButton = QPushButton("Test GPS", self)
self.testGPSButton.clicked.connect(self._testGPS)
top.addWidget(self.testGPSButton)
connectBox = QHBoxLayout()
top.addLayout(connectBox)
self.connectGPSButton = QCheckBox('GPS Connect', self)
self.connectGPSButton.clicked.connect(self._connectGPS)
self.connectGPSButton.setChecked(self.connectGPSEnable)
connectBox.addWidget(self.connectGPSButton)
self.setGeometry(0, 0, 800, 400)
self.setWindowTitle('GPS Test')
self.updateGPSThread = GPSUpateWorkerGPSD(self)
self.connect(self.updateGPSThread, SIGNAL("updateStatus(QString)"),
self.updateStatusLabel)
self.connect(self.updateGPSThread, SIGNAL("connectGPSFailed()"),
self.connectGPSFailed)
self.connect(self.updateGPSThread,
SIGNAL("updateGPSDisplay(PyQt_PyObject)"),
self.updateGPSDisplay)
self._connectGPS()
self.show()
def __init__(self):
QWidget.__init__(self)
vl = QVBoxLayout()
self.setLayout(vl)
table = ResultsTable()
vl.addWidget(table)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignRight)
vl.addLayout(hl)
delete_all_button = QPushButton('Delete all')
delete_all_button.clicked.connect(self._on_delete_all_clicked)
hl.addWidget(delete_all_button)
def put_checkbox(self, qtable, rows, checker, value):
""" Set one column of a QtableView as QCheckBox with values from database. """
for x in range(0, len(rows)):
row = rows[x]
cell_widget = QWidget()
chk = QCheckBox()
if row[checker] == value:
chk.setCheckState(Qt.Checked)
lay_out = QHBoxLayout(cell_widget)
lay_out.addWidget(chk)
lay_out.setAlignment(Qt.AlignCenter)
lay_out.setContentsMargins(0, 0, 0, 0)
cell_widget.setLayout(lay_out)
i = qtable.model().index(x, self.chk_position)
qtable.setIndexWidget(i, cell_widget)
def init_ui(self, title):
self.setWindowTitle(title)
btn_close = create_button('Close', self.close)
buttons = QHBoxLayout()
buttons.addWidget(btn_close)
buttons.setAlignment(Qt.AlignBottom)
body = QVBoxLayout()
body.setAlignment(Qt.AlignTop)
header = QLabel(
_('Select which parts of Anki should be displayed '
'in eye-friendly, dark colors.\n\n'
'To disable all dialog windows, '
'use the "Enable in dialogs" switch which is available in menu.')
)
header.setAlignment(Qt.AlignCenter)
stylers = QVBoxLayout()
stylers.setAlignment(Qt.AlignTop)
for styler in sorted(self.all_stylers, key=lambda s: s.name):
styler_checkbox = StylerCheckButton(self, styler)
self.stylers_checkboxes.append(styler_checkbox)
stylers.addWidget(styler_checkbox)
self.stylers_layout = stylers
checked_boxes = sum(1 for checkbox in self.stylers_checkboxes
if checkbox.isChecked())
check_all = QCheckBox(_('Check/uncheck all'), self)
check_all.setChecked(checked_boxes > len(self.stylers_checkboxes) / 2)
check_all.stateChanged.connect(self.check_uncheck_all)
body.addWidget(header)
body.addWidget(check_all)
body.addLayout(stylers)
body.addStretch(1)
body.addLayout(buttons)
self.setLayout(body)
self.setGeometry(300, 300, 350, 300)
self.show()
def _configurarGui(self, texto):
layout = QHBoxLayout()
layout.setAlignment(Qt.AlignLeft)
layout.setMargin(0)
self._spacer = QSpacerItem(0,0,QSizePolicy.Expanding,QSizePolicy.Maximum)
self._layoutSpacer = QHBoxLayout()
self._layoutSpacer.addItem(self._spacer)
lbl = QLabel('Nome: ', self)
self._lblNome = EditLabel(texto)
self._btnGravar = QPushButton('Modificar')
layout.addWidget(lbl)
layout.addWidget(self._lblNome)
layout.addLayout(self._layoutSpacer)
layout.addWidget(self._btnGravar)
self.setLayout(layout)
def _getCenteredCheckbox(self, checked = True):
'''
Get a centered checkbox to insert in a table widget
:returns: A widget with a centered checkbox
:rtype: QWidget
'''
widget = QWidget()
checkBox = QCheckBox()
checkBox.setChecked(checked)
layout = QHBoxLayout(widget)
layout.addWidget(checkBox);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(0,0,0,0);
widget.setLayout(layout);
return widget
def _getCenteredCheckbox(self, checked=True):
'''
Get a centered checkbox to insert in a table widget
:returns: A widget with a centered checkbox
:rtype: QWidget
'''
widget = QWidget()
checkBox = QCheckBox()
checkBox.setChecked(checked)
layout = QHBoxLayout(widget)
layout.addWidget(checkBox)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
return widget
class NetObjectTitle(QWidget):
def __init__(self, text_items, abstract, menu, parent=None):
QWidget.__init__(self, parent)
self.row_layout = QHBoxLayout(self)
self.row_layout.setMargin(0)
self.row_layout.setAlignment(Qt.AlignLeft)
self.details_button = DetailsButton()
self.row_layout.addWidget(self.details_button)
for widget in (self.details_button, self):
self.connect(widget, SIGNAL('clicked()'), self.updateView)
for text in text_items:
label = QLabel()
label.setText("<h2>%s</h2>" % text)
self.row_layout.addWidget(label)
self.abstract = abstract
if abstract is None:
return
self.row_layout.addWidget(abstract)
self.row_layout.addStretch()
self.edit_button = EditButton(menu)
self.row_layout.addWidget(self.edit_button)
def updateView(self):
if self.abstract is None:
return
if self.details_button.expanded:
self.abstract.hide()
else:
self.abstract.show()
def mouseDoubleClickEvent(self, event):
"""
double clicking on elements' title bar has the same effect
as clicking on expand/collapse button
"""
self.details_button.emit(SIGNAL('clicked()'))
def _getCombobox(self,
values,
primary_selected_value=None,
secondary_selected_value=None,
currentindex_changed_callback=None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
combobox = QComboBox()
layout = QHBoxLayout(widget)
layout.addWidget(combobox, 1)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(5, 0, 5, 0)
widget.setLayout(layout)
current_item_index = 0
selected_index = 0
for key, value in values.iteritems():
combobox.addItem(value, key)
# Select value
if key == secondary_selected_value and selected_index == 0:
selected_index = current_item_index
if key == primary_selected_value:
selected_index = current_item_index
current_item_index += 1
combobox.setCurrentIndex(selected_index)
if currentindex_changed_callback is not None:
combobox.currentIndexChanged.connect(currentindex_changed_callback)
return widget
def __init__(self, parent, data, xy, readonly):
QWidget.__init__(self, parent)
self.data = data
self.old_data_shape = None
if len(self.data.shape) == 1:
self.old_data_shape = self.data.shape
self.data.shape = (self.data.shape[0], 1)
elif len(self.data.shape) == 0:
self.old_data_shape = self.data.shape
self.data.shape = (1, 1)
self.changes = {}
format = SUPPORTED_FORMATS.get(data.dtype.name, '%s')
self.model = ArrayModel(self.data,
self.changes,
format=format,
xy_mode=xy,
readonly=readonly,
parent=self)
self.view = ArrayView(self, self.model, data.dtype, data.shape)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignLeft)
btn = QPushButton(translate("ArrayEditor", "Format"))
# disable format button for int type
btn.setEnabled(is_float(data.dtype))
btn_layout.addWidget(btn)
self.connect(btn, SIGNAL("clicked()"), self.change_format)
btn = QPushButton(translate("ArrayEditor", "Resize"))
btn_layout.addWidget(btn)
self.connect(btn, SIGNAL("clicked()"), self.view.resize_to_contents)
bgcolor = QCheckBox(translate("ArrayEditor", 'Background color'))
bgcolor.setChecked(self.model.bgcolor_enabled)
bgcolor.setEnabled(self.model.bgcolor_enabled)
self.connect(bgcolor, SIGNAL("stateChanged(int)"), self.model.bgcolor)
btn_layout.addWidget(bgcolor)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(btn_layout)
self.setLayout(layout)
class QScrolledTerminalWidget(QWidget):
def __init__(self,parent, font_name, font_size, cols, rows, colorscheme):
super().__init__(parent)
self.callback_scrollbar= None
#
# determine font metrics and terminal window size in pixel
#
font= QFont(font_name)
font.setPixelSize(font_size)
metrics= QFontMetrics(font)
font_width=metrics.width("A")
font_height=metrics.height()
width= font_width*cols
height= int(font_height* rows)
#
# create terminal window and scrollbar
#
self.hbox= QHBoxLayout()
self.terminalwidget= QTerminalWidget(self,font_name,font_size,font_height, width,height, colorscheme)
self.hbox.addWidget(self.terminalwidget)
self.hbox.setAlignment(self.terminalwidget,Qt.AlignLeft)
self.scrollbar= QScrollBar()
self.hbox.addWidget(self.scrollbar)
self.hbox.setAlignment(self.scrollbar,Qt.AlignLeft)
self.setLayout(self.hbox)
#
# initialize scrollbar
#
self.scrollbar.valueChanged.connect(self.do_scrollbar)
self.scrollbar.setEnabled(False)
#
# scrollbar value changed action
#
def do_scrollbar(self):
self.callback_scrollbar(self.scrollbar.value())
#
# register callback for scrolling
#
def register_callback_scrollbar(self,func):
self.callback_scrollbar=func
self.scrollbar.setEnabled(True)
def _getTextbox(self, value = None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
textbox = QLineEdit()
textbox.setText(value)
layout = QHBoxLayout(widget)
layout.addWidget(textbox, 1);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(5,0,5,0);
widget.setLayout(layout);
return widget
def _getTextbox(self, value=None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
textbox = QLineEdit()
textbox.setText(value)
layout = QHBoxLayout(widget)
layout.addWidget(textbox, 1)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(5, 0, 5, 0)
widget.setLayout(layout)
return widget
def _getCombobox(self, values, primary_selected_value = None, secondary_selected_value = None, currentindex_changed_callback = None):
'''
Get a combobox filled with the given values
:param values: The values as key = value, value = description or text
:type values: Dict
:returns: A combobox
:rtype: QWidget
'''
widget = QWidget()
combobox = QComboBox()
layout = QHBoxLayout(widget)
layout.addWidget(combobox, 1);
layout.setAlignment(Qt.AlignCenter);
layout.setContentsMargins(5,0,5,0);
widget.setLayout(layout);
current_item_index = 0
selected_index = 0
for key, value in values.iteritems():
combobox.addItem(value, key)
# Select value
if key == secondary_selected_value and selected_index == 0:
selected_index = current_item_index
if key == primary_selected_value:
selected_index = current_item_index
current_item_index += 1
combobox.setCurrentIndex(selected_index)
if currentindex_changed_callback is not None:
combobox.currentIndexChanged.connect(currentindex_changed_callback)
return widget
def __init__(self, parent, data, xy, readonly):
QWidget.__init__(self, parent)
self.data = data
self.old_data_shape = None
if len(self.data.shape) == 1:
self.old_data_shape = self.data.shape
self.data.shape = (self.data.shape[0], 1)
elif len(self.data.shape) == 0:
self.old_data_shape = self.data.shape
self.data.shape = (1, 1)
self.changes = {}
format = SUPPORTED_FORMATS.get(data.dtype.name, '%s')
self.model = ArrayModel(self.data, self.changes, format=format,
xy_mode=xy, readonly=readonly, parent=self)
self.view = ArrayView(self, self.model, data.dtype, data.shape)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignLeft)
btn = QPushButton(translate("ArrayEditor", "Format"))
# disable format button for int type
btn.setEnabled(is_float(data.dtype))
btn_layout.addWidget(btn)
self.connect(btn, SIGNAL("clicked()"), self.change_format)
btn = QPushButton(translate("ArrayEditor", "Resize"))
btn_layout.addWidget(btn)
self.connect(btn, SIGNAL("clicked()"), self.view.resize_to_contents)
bgcolor = QCheckBox(translate("ArrayEditor", 'Background color'))
bgcolor.setChecked(self.model.bgcolor_enabled)
bgcolor.setEnabled(self.model.bgcolor_enabled)
self.connect(bgcolor, SIGNAL("stateChanged(int)"), self.model.bgcolor)
btn_layout.addWidget(bgcolor)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(btn_layout)
self.setLayout(layout)
def __init__(self,
model,
check_label="Do this",
help_link="",
show_label=True,
alt_label=None,
default_check_state=True):
"""Construct a checkbox widget for booleans"""
HelpedWidget.__init__(self, check_label, help_link)
if show_label:
if alt_label != None:
self.check = QCheckBox(alt_label, self)
else:
self.check = QCheckBox(check_label, self)
else:
self.check = QCheckBox(self)
self.check.setTristate(False)
self.check.setChecked(default_check_state)
self.connect(self.check, QtCore.SIGNAL('stateChanged(int)'),
self.contentsChanged)
if not show_label:
layout = QHBoxLayout()
layout.addWidget(self.check)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(0, 0, 0, 0)
self.addLayout(layout)
else:
self.addWidget(self.check)
assert isinstance(model, BooleanModelMixin)
self.model = model
self.model.observable().attach(
BooleanModelMixin.BOOLEAN_VALUE_CHANGED_EVENT, self.modelChanged)
self.modelChanged()
def init_ui(self, title):
self.setWindowTitle(_(title))
btn_add_mapping = create_button('+ Add colors mapping', self.on_add)
btn_close = create_button('Close', self.close)
buttons = QHBoxLayout()
buttons.addWidget(btn_close)
buttons.addWidget(btn_add_mapping)
buttons.setAlignment(Qt.AlignBottom)
body = QVBoxLayout()
body.setAlignment(Qt.AlignTop)
header = QLabel(
_('Specify how particular colors on your cards '
'should be swapped when the night mode is on.'))
header.setAlignment(Qt.AlignCenter)
mappings = QVBoxLayout()
mappings.setAlignment(Qt.AlignTop)
for normal_color, night_color in self.color_map.items():
mapping = ColorMapping(self, normal_color, night_color)
mappings.addWidget(mapping)
self.mappings = mappings
body.addWidget(header)
body.addLayout(mappings)
body.addStretch(1)
body.addLayout(buttons)
self.setLayout(body)
self.setGeometry(300, 300, 350, 300)
self.show()
def __init__(self):
super(QWidget, self).__init__()
if ResultTab.__instance is None :
ResultTab.__instance = self
self.phases = []
self.values = []
self.import_phases = []
self.import_values = []
self.export = None
self.vl = QVBoxLayout()
header = ['Phase', 'Synthetic', 'Observation', 'Delta']
self.table = QTableWidget()
self.table.verticalHeader().setVisible(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setColumnCount(len(header))
self.table.setHorizontalHeaderLabels(header)
self.vl.addWidget(self.table)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignRight)
export_button = QPushButton('Export...')
export_menu = QMenu()
export_menu.addAction('\\t separated').triggered.connect(lambda : self._on_export('\t'))
export_menu.addAction(', separated').triggered.connect(lambda : self._on_export(','))
export_menu.addAction('; separated').triggered.connect(lambda : self._on_export(';'))
export_button.setMenu(export_menu)
hl.addWidget(export_button)
self.vl.addLayout(hl)
self.setLayout(self.vl)
def __init__(self, parent=None, show_fullpath=True, fullpath_sorting=True,
show_all_files=True):
QWidget.__init__(self, parent)
self.treewidget = ClassBrowserTreeWidget(self,
show_fullpath=show_fullpath,
fullpath_sorting=fullpath_sorting,
show_all_files=show_all_files)
self.visibility_action = create_action(self,
self.tr("Show/hide class browser"),
icon='class_browser_vis.png',
toggled=self.toggle_visibility)
self.visibility_action.setChecked(True)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignRight)
for btn in self.setup_buttons():
btn_layout.addWidget(btn)
layout = QVBoxLayout()
layout.addWidget(self.treewidget)
layout.addLayout(btn_layout)
self.setLayout(layout)
def genOneTab(self):
tabtitle = QLabel()
# tabtitle.setFixedHeight(40)
# tabtitle.setFixedWidth(160)
self.btn_start = MyButton("开始")
self.choicenum_text = QComboBox()
self.choicenum_text.setObjectName('w1combonums')
# self.w1title.setStyleSheet("background-image:url('image/panelbg.jpg');")
# Set the title style
tabtitle.setFont(QFont('Courier New', 20))
tabtitle.setText("随堂提问演板")
tabtitle.setStyleSheet("border: 1px solid blue; color:rgba(0,0,255, 220);\
background-color:rgba(201,201,201,60);\
border-radius: 6px; \
padding: 1px 18px 1px 20px;\
min-width: 8em;")
tabtitle.setMinimumHeight(50);
titleLayout = QHBoxLayout()
titleLayout.addWidget(tabtitle)
titleLayout.setAlignment(tabtitle, Qt.AlignCenter)
btnlayout = QGridLayout()
tmpnum = 0
for inum in range(0,56):
irow = tmpnum // g_cols
icol = tmpnum % g_cols
tmpnum += 1
btnlayout.setRowMinimumHeight(irow, 80)
tmpbtn = MyButton("")
tmpbtn.setMyarg(None)
# tmpbtn.setFixedHeight(20)
tmpbtn.setSizePolicy(QSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding))
tmpbtn.setStyleSheet("border: 1px solid rgb(55,55,255,100);background-color: rgba(255,255,255,20);font-size:16px;")
self.connect(tmpbtn, SIGNAL("myslot(PyQt_PyObject)"), self.myslot)
tmpbtn.setAutoDefault(False)
self.btngroup.addButton(tmpbtn, inum+1) # stusn is from 1 start
btnlayout.addWidget(tmpbtn, irow, icol)
self.btn_start.setIcon(QIcon("image/start.png"))
self.btn_start.setStyleSheet("border: 1px solid yellow;")
self.btn_start.setFixedHeight(40)
self.btn_start.setFixedWidth(100)
self.btn_start.setFont(QFont('宋体', 18))
# self.choicenum_text.setFixedHeight(45)
# self.choicenum_text.setFixedWidth(60)
## Set the combox number style
self.choicenum_text.setFont(QFont('Courier New', 20))
self.choicenum_text.setFixedHeight(45)
self.choicenum_text.setStyleSheet("border: 2px solid blue; color:red;font-weight:light;font-size:26px;\
border-radius: 6px; \
min-width: 2em; ")
self.choicenum_text.setEditable(True)
self.choicenum_text.lineEdit().setReadOnly(True);
self.choicenum_text.lineEdit().setAlignment(Qt.AlignCenter);
model = self.choicenum_text.model()
for row in list(range(1, 7)):
item = QStandardItem(str(row))
item.setTextAlignment(Qt.AlignCenter)
item.setForeground(QColor('red'))
item.setBackground(QColor(0,200,50, 130))
model.appendRow(item)
self.choicenum_text.setCurrentIndex(2)
# self.choicenum_text.setStyleSheet ("QComboBox::drop-down {border-width: 100px;}")
# self.choicenum_text.setStyleSheet ("QComboBox::down-arrow {image: url(image/downarrow.png);top: 10px;left: 1px;}")
bottomlayout = QHBoxLayout()
bottomlayout.setSizeConstraint(QLayout.SetFixedSize)
bottomlayout.addStretch(10)
bottomlayout.addWidget(self.btn_start)
bottomlayout.setSpacing(5)
bottomlayout.addWidget(self.choicenum_text)
tab1layout = QVBoxLayout()
tab1layout.addLayout(titleLayout)
tab1layout.addLayout(btnlayout)
tab1layout.addLayout(bottomlayout)
self.w1.setLayout(tab1layout)
self.w1.setStyleSheet("background-color: QLinearGradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #ffffff, stop: 1 #228888);")
class HoldingRnpDlg(FlightPlanBaseDlg):
'''
classdocs
'''
def __init__(self, parent):
'''
Constructor
'''
FlightPlanBaseDlg.__init__(self, parent)
self.setObjectName("HoldingRnp")
self.surfaceType = SurfaceTypes.HoldingRnp
self.initParametersPan()
self.setWindowTitle(SurfaceTypes.HoldingRnp)
self.resize(540, 550)
QgisHelper.matchingDialogSize(self, 710, 700)
# point1 = Point3D(670765.834204, 6624159.01137)
# point2 = Point3D(658888.622249, 6631328.51407)
# point3 = Point3D(648258.512784, 6624159.01137)
# b = MathHelper.smethod_60(point1, point2, point3)
# pass
def exportResult(self):
result, resultHideColumnNames = FlightPlanBaseDlg.exportResult(self)
if not result:
return
filePathDir = QFileDialog.getSaveFileName(
self, "Export Obstacle Data",
QCoreApplication.applicationDirPath(),
"ExportObstaclefiles(*.xml)")
if filePathDir == "":
return
# self.filterList = []
# for taaArea in self.taaCalculationAreas:
# self.filterList.append(taaArea.title)
parameterList = self.getParameterList()
DataHelper.saveExportResult(filePathDir, SurfaceTypes.HoldingRnp,
self.ui.tblObstacles, None, parameterList,
resultHideColumnNames)
# self.obstaclesModel.setFilterFixedString(self.filterList[self.ui.cmbObstSurface.currentIndex()])
# return FlightPlanBaseDlg.exportResult(self)
def getParameterList(self):
parameterList = []
parameterList.append(("general", "group"))
parameterList.append(("Waypoint Position", "group"))
longLatPoint = QgisHelper.Meter2Degree(
float(self.parametersPanel.pnlWaypoint.txtPointX.text()),
float(self.parametersPanel.pnlWaypoint.txtPointY.text()))
parameterList.append(
("Lat", self.parametersPanel.pnlWaypoint.txtLat.Value))
parameterList.append(
("Lon", self.parametersPanel.pnlWaypoint.txtLong.Value))
parameterList.append(
("X", self.parametersPanel.pnlWaypoint.txtPointX.text()))
parameterList.append(
("Y", self.parametersPanel.pnlWaypoint.txtPointY.text()))
parameterList.append(("Parameters", "group"))
parameterList.append(
("RNP Value", self.parametersPanel.txtRnpValue.text()))
# parameterList.append(("Aircraft Category", self.parametersPanel.cmbAircraftCategory_2.currentText()))
parameterList.append(
("IAS", self.parametersPanel.txtIas.text() + "kts"))
parameterList.append(
("TAS", self.parametersPanel.txtTas.text() + "kts"))
parameterList.append(
("Altitude", self.parametersPanel.txtAltitudeM.text() + "m"))
parameterList.append(
("", self.parametersPanel.txtAltitude.text() + "ft"))
parameterList.append(
("ISA",
self.parametersPanel.txtIsa.text() + unicode("°C", "utf-8")))
parameterList.append(
("Wind", self.parametersPanel.pnlWind.speedBox.text() + "kts"))
parameterList.append(
("Time", self.parametersPanel.txtTime.text() + "min"))
parameterList.append(("MOC", self.parametersPanel.txtMoc.text() + "m"))
parameterList.append(("", self.parametersPanel.txtMocFt.text() + "ft"))
parameterList.append(
("Construction Type",
self.parametersPanel.cmbConstruction.currentText()))
parameterList.append(("Orientation", "group"))
parameterList.append(
("In-bound Trak", "Plan : " +
str(self.parametersPanel.txtTrack.txtRadialPlan.Value) +
define._degreeStr))
parameterList.append(
("", "Geodetic : " +
str(self.parametersPanel.txtTrack.txtRadialGeodetic.Value) +
define._degreeStr))
# parameterList.append(("In-bound Trak", self.parametersPanel.txtTrack.Value + unicode("°", "utf-8")))
parameterList.append(
("Turns", self.parametersPanel.cmbOrientation.currentText()))
parameterList.append(("Results / Checked Obstacles", "group"))
parameterList.append(("Checked Obstacles", "group"))
c = self.obstaclesModel.rowCount()
parameterList.append(("Number of Checked Obstacles", str(c)))
return parameterList
def initObstaclesModel(self):
ObstacleTable.MocMultiplier = self.parametersPanel.mocSpinBox.value()
self.obstaclesModel = HoldingRnpObstacles(
self.surfaceList,
Altitude(float(self.parametersPanel.txtMoc.text())),
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT))
return FlightPlanBaseDlg.initObstaclesModel(self)
def btnEvaluate_Click(self):
polylines = self.method_36(False)
# polylines[0].Dispose();
# polylines.RemoveAt(0);
count = len(polylines)
num = 0.1 * count
altitudeMoc = Altitude(float(self.parametersPanel.txtMoc.text()),
AltitudeUnits.M)
metres = altitudeMoc.Metres
holdingRnpAreas = []
for i in range(count):
if (i > 0):
metres = num * altitudeMoc.Metres
num = num - 0.1
point3dCollection = polylines[i].method_14_closed(6)
polylineArea0 = PolylineArea(point3dCollection)
holdingRnpAreas.append(
HoldingRnpArea(polylineArea0, Altitude(metres)))
self.surfaceList = holdingRnpAreas
return FlightPlanBaseDlg.btnEvaluate_Click(self)
def btnConstruct_Click(self):
flag = FlightPlanBaseDlg.btnConstruct_Click(self)
if not flag:
return
mapUnits = define._canvas.mapUnits()
constructionLayer = None
polylines = self.method_36(True)
pollineAreaLineList, polylineAreaArcList, centerPolylineArea = self.method_36_Construct(
True)
if (self.parametersPanel.cmbConstruction.currentText() !=
ConstructionType.Construct3D):
constructionLayer = AcadHelper.createVectorLayer(
self.surfaceType, QGis.Line)
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer,
centerPolylineArea,
True)
for polrlineArea in pollineAreaLineList:
AcadHelper.setGeometryAndAttributesInLayer(
constructionLayer, polrlineArea)
for polrlineArea in polylineAreaArcList:
AcadHelper.setGeometryAndAttributesInLayer(
constructionLayer, polrlineArea)
else:
constructionLayer = AcadHelper.createVectorLayer(
self.surfaceType, QGis.Polygon)
# if define._mapCrs == None:
# if mapUnits == QGis.Meters:
# constructionLayer = QgsVectorLayer("polygon?crs=EPSG:32633", self.surfaceType, "memory")
# else:
# constructionLayer = QgsVectorLayer("polygon?crs=EPSG:4326", self.surfaceType, "memory")
# else:
# constructionLayer = QgsVectorLayer("polygon?crs=%s"%define._mapCrs.authid (), self.surfaceType, "memory")
# constructionLayer.startEditing()
count = len(polylines)
num = 0.1 * count
altitude = Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)
value = Altitude(float(self.parametersPanel.txtMoc.text()),
AltitudeUnits.M)
metres = altitude.Metres - value.Metres
for i in range(count):
AcadHelper.setGeometryAndAttributesInLayer(
constructionLayer, polylines[len(polylines) - 1 - i], True)
# polygon1 = QgsGeometry.fromPolygon([polylines[i].method_14_closed(6)])
# polygonNew = polygon1
# if (i > 0):
# metres1 = altitude.Metres
# # value = self.pnlMoc.Value;
# metres = metres1 - num * value.Metres
# num = num - 0.1
# if (i > 0):
# polygon0 = QgsGeometry.fromPolygon([polylines[i - 1].method_14_closed(6)])
# polygonNew = polygon1.difference(polygon0)
# feature = QgsFeature()
# feature.setGeometry(polygonNew)
# constructionLayer.addFeature(feature)
# constructionLayer.commitChanges()
QgisHelper.appendToCanvas(define._canvas, [constructionLayer],
SurfaceTypes.HoldingRnp)
self.resultLayerList = [constructionLayer]
self.ui.btnEvaluate.setEnabled(True)
def uiStateInit(self):
self.ui.grbMostCritical.setVisible(False)
self.ui.grbResult_2.setVisible(False)
self.ui.btnUpdateQA.setVisible(False)
self.ui.btnUpdateQA_2.setVisible(False)
self.ui.frm_cmbObstSurface.setVisible(False)
self.ui.tabCtrlGeneral.removeTab(2)
# self.ui.btnPDTCheck.clicked.connect(self.btnPDTCheck_Click)
return FlightPlanBaseDlg.uiStateInit(self)
def btnPDTCheck_Click(self):
pdtResultStr = ""
K = round(
171233 * math.pow(
288 + float(self.parametersPanel.txtIsa.text()) - 0.00198 *
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT).Feet, 0.5) /
(math.pow(
288 - 0.00198 *
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT).Feet, 2.628)), 4)
pdtResultStr = "1. K = \t" + str(K) + "\n"
V = Speed.smethod_0(
Speed(float(self.parametersPanel.txtIas.text())),
float(self.parametersPanel.txtIsa.text()),
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)).Knots
pdtResultStr += "2. V = \t" + str(V) + "kt\n"
v = V / 3600
pdtResultStr += "3. v = \t" + str(v) + "NM/s\n"
R = 509.26 / V
pdtResultStr += "4. R = \t" + str(R) + unicode("°/s", "utf-8") + "\n"
r = V / (62.83 * R)
pdtResultStr += "5. r = \t" + str(r) + "NM\n"
h = float(self.parametersPanel.txtAltitude.text()) / 1000
pdtResultStr += "6. h = \t" + str(h) + "\n"
w = 2 * h + 47
pdtResultStr += "7. w = \t" + str(w) + "kt\n"
wd = w / 3600
pdtResultStr += "8. w' = \t" + str(wd) + "NM/s\n"
E45 = 45 * wd / R
pdtResultStr += "9. E45' = \t" + str(E45) + "NM\n"
t = 60 * float(self.parametersPanel.txtTime.text())
pdtResultStr += "10. t = \t" + str(t) + "s\n"
L = v * t
pdtResultStr += "11. L = \t" + str(L) + "NM\n"
ab = 5 * v
pdtResultStr += "12. ab = \t" + str(ab) + "NM\n"
ac = 11 * v
pdtResultStr += "13. ac = \t" + str(ac) + "NM\n"
gi1 = (t - 5) * v
pdtResultStr += "14. gi1 = gi3 = \t" + str(gi1) + "NM\n"
gi2 = (t + 21) * v
pdtResultStr += "15. gi2 = gi4 = \t" + str(gi2) + "NM\n"
Wb = 5 * wd
pdtResultStr += "16. Wb = \t" + str(Wb) + "NM\n"
Wc = 11 * wd
pdtResultStr += "17. Wc = \t" + str(Wc) + "NM\n"
Wd = Wc + E45
pdtResultStr += "18. Wd = \t" + str(Wd) + "NM\n"
We = Wc + 2 * E45
pdtResultStr += "19. We = \t" + str(We) + "NM\n"
Wf = Wc + 3 * E45
pdtResultStr += "20. Wf = \t" + str(Wf) + "NM\n"
Wg = Wc + 4 * E45
pdtResultStr += "21. Wg = \t" + str(Wg) + "NM\n"
Wh = Wb + 4 * E45
pdtResultStr += "22. Wh = \t" + str(Wh) + "NM\n"
Wo = Wb + 5 * E45
pdtResultStr += "23. Wo = \t" + str(Wo) + "NM\n"
Wp = Wb + 6 * E45
pdtResultStr += "24. Wp = \t" + str(Wp) + "NM\n"
Wi1 = (t + 6) * wd + 4 * E45
pdtResultStr += "25. Wi1 = Wi3 = \t" + str(Wi1) + "NM\n"
Wi2 = Wi1 + 14 * wd
pdtResultStr += "26. Wi2 = Wi4 = \t" + str(Wi2) + "NM\n"
Wj = Wi2 + E45
pdtResultStr += "27. Wj = \t" + str(Wj) + "NM\n"
Wk = Wi2 + 2 * E45
pdtResultStr += "28. Wk = Wi = \t" + str(Wk) + "NM\n"
Wm = Wi2 + 3 * E45
pdtResultStr += "29. Wm = \t" + str(Wm) + "NM\n"
Wn3 = Wi1 + 4 * E45
pdtResultStr += "30. Wn3 = \t" + str(Wn3) + "NM\n"
Wn4 = Wi2 + 4 * E45
pdtResultStr += "31. Wn4 = \t" + str(Wn4) + "NM\n"
XE = 2 * r + (t + 15) * v + (t + 26 + 195 / R) * wd
pdtResultStr += "32. XE = \t" + str(XE) + "NM\n"
YE = 11 * v * math.cos(math.pi * 20 / 180) + r * (
1 + math.sin(math.pi * 20 / 180)) + (t + 15) * v * math.tan(
math.pi * 5 / 180) + (t + 26 + 125 / R) * wd
pdtResultStr += "33. YE = \t" + str(YE) + "NM"
QMessageBox.warning(self, "PDT Check", pdtResultStr)
def initParametersPan(self):
ui = Ui_HoldingRnpGeneral()
self.parametersPanel = ui
FlightPlanBaseDlg.initParametersPan(self)
self.parametersPanel.txtTas.setEnabled(False)
self.parametersPanel.pnlWaypoint = PositionPanel(
self.parametersPanel.holding)
self.parametersPanel.pnlWaypoint.groupBox.setTitle("Waypoint Position")
self.parametersPanel.pnlWaypoint.hideframe_Altitude()
self.parametersPanel.pnlWaypoint.setObjectName("positionWaypoint")
self.parametersPanel.pnlWaypoint.btnCalculater.hide()
self.parametersPanel.verticalLayout.insertWidget(
0, self.parametersPanel.pnlWaypoint)
self.parametersPanel.pnlWind = WindPanel(
self.parametersPanel.grbParameters)
self.parametersPanel.vLayout_grbParameters.insertWidget(
5, self.parametersPanel.pnlWind)
self.parametersPanel.pnlWind.setAltitude(
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT))
# self.resize(460,600)
self.parametersPanel.cmbConstruction.addItems(["2D", "3D"])
self.parametersPanel.cmbAircraftCategory_2.addItems(
["A", "B", "C", "D", "E", "H", "Custom"])
self.parametersPanel.cmbOrientation.addItems(
[OrientationType.Left, OrientationType.Right])
# self.parametersPanel.cmbOrientation.setCurrentIndex(1)
#
# '''Event Handlers Connect'''
#
self.parametersPanel.txtAltitude.textChanged.connect(self.method_31)
# self.parametersPanel.cmbTurnLimitation.currentIndexChanged.connect(self.method_28)
# self.parametersPanel.btnCaptureTrack.clicked.connect(self.captureBearing)
self.parametersPanel.cmbAircraftCategory_2.currentIndexChanged.connect(
self.changeCategory)
self.parametersPanel.cmbAircraftCategory_2.setCurrentIndex(3)
self.frame_8_1 = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
# sizePolicy.setHeightForWidth(self.frame_8.sizePolicy().hasHeightForWidth())
self.frame_8_1.setSizePolicy(sizePolicy)
self.frame_8_1.setFrameShape(QFrame.StyledPanel)
self.frame_8_1.setFrameShadow(QFrame.Raised)
self.frame_8_1.setObjectName("frame_8")
self.horizontalLayout_10_1 = QHBoxLayout(self.frame_8_1)
self.horizontalLayout_10_1.setAlignment(Qt.AlignHCenter)
self.horizontalLayout_10_1.setSpacing(0)
self.horizontalLayout_10_1.setMargin(0)
self.horizontalLayout_10_1.setObjectName("horizontalLayout_10")
self.label_2_1 = QLabel(self.frame_8_1)
self.label_2_1.setMinimumSize(QSize(140, 16777215))
# self.label_2_1.setFixedWidth(100)
self.label_2_1.setText("MOCmultiplier")
font = QFont()
font.setFamily("Arial")
font.setBold(False)
font.setWeight(50)
self.label_2_1.setFont(font)
self.label_2_1.setObjectName("label_2_1")
self.horizontalLayout_10_1.addWidget(self.label_2_1)
self.parametersPanel.mocSpinBox = QSpinBox(self.frame_8_1)
self.parametersPanel.mocSpinBox.setFont(font)
self.parametersPanel.mocSpinBox.setObjectName("mocSpinBox")
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.parametersPanel.mocSpinBox.sizePolicy().hasHeightForWidth())
self.parametersPanel.mocSpinBox.setSizePolicy(sizePolicy)
self.parametersPanel.mocSpinBox.setMinimum(1)
self.parametersPanel.mocSpinBox.setMinimumSize(QSize(140, 16777215))
# self.parametersPanel.mocSpinBox.setFixedWidth(100)
self.horizontalLayout_10_1.addWidget(self.parametersPanel.mocSpinBox)
# self.verticalLayout_9.addWidget(self.frame_8_1)
self.parametersPanel.vLayout_grbParameters.addWidget(self.frame_8_1)
self.parametersPanel.btnIasHelp.clicked.connect(self.iasHelpShow)
self.parametersPanel.frame_ConstructionType_2.hide()
self.parametersPanel.txtIas.textChanged.connect(self.iasChanged)
self.parametersPanel.txtIsa.textChanged.connect(self.isaChanged)
# self.parametersPanel.txtIsa.textChanged.connect(self.isaChanged)
self.parametersPanel.txtAltitudeM.textChanged.connect(
self.txtAltitudeMChanged)
self.parametersPanel.txtAltitude.textChanged.connect(
self.txtAltitudeFtChanged)
self.flag = 0
if self.flag == 0:
self.flag = 2
if self.flag == 1:
self.flag = 0
if self.flag == 2:
try:
self.parametersPanel.txtAltitudeM.setText(
str(
round(
Unit.ConvertFeetToMeter(
float(
self.parametersPanel.txtAltitude.text())),
4)))
except:
self.parametersPanel.txtAltitudeM.setText("0.0")
self.parametersPanel.txtMoc.textChanged.connect(self.txtMocMChanged)
self.parametersPanel.txtMocFt.textChanged.connect(self.txtMocFtChanged)
self.flag1 = 0
if self.flag1 == 0:
self.flag1 = 1
if self.flag1 == 2:
self.flag1 = 0
if self.flag1 == 1:
try:
self.parametersPanel.txtMocFt.setText(
str(
round(
Unit.ConvertMeterToFeet(
float(self.parametersPanel.txtMoc.text())),
4)))
except:
self.parametersPanel.txtMocFt.setText("0.0")
self.parametersPanel.txtTas.setText(
str(
round(
Speed.smethod_0(
Speed(float(self.parametersPanel.txtIas.text())),
float(self.parametersPanel.txtIsa.text()),
Altitude(
float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)).Knots, 4)))
def txtAltitudeMChanged(self):
if self.flag == 0:
self.flag = 1
if self.flag == 2:
self.flag = 0
if self.flag == 1:
try:
self.parametersPanel.txtAltitude.setText(
str(
round(
Unit.ConvertMeterToFeet(
float(
self.parametersPanel.txtAltitudeM.text())),
4)))
except:
self.parametersPanel.txtAltitude.setText("0.0")
def txtAltitudeFtChanged(self):
if self.flag == 0:
self.flag = 2
if self.flag == 1:
self.flag = 0
if self.flag == 2:
try:
self.parametersPanel.txtAltitudeM.setText(
str(
round(
Unit.ConvertFeetToMeter(
float(
self.parametersPanel.txtAltitude.text())),
4)))
except:
self.parametersPanel.txtAltitudeM.setText("0.0")
def txtMocMChanged(self):
if self.flag1 == 0:
self.flag1 = 1
if self.flag1 == 2:
self.flag1 = 0
if self.flag1 == 1:
try:
self.parametersPanel.txtMocFt.setText(
str(
round(
Unit.ConvertMeterToFeet(
float(self.parametersPanel.txtMoc.text())),
4)))
except:
self.parametersPanel.txtMocFt.setText("0.0")
def txtMocFtChanged(self):
if self.flag1 == 0:
self.flag1 = 2
if self.flag1 == 1:
self.flag1 = 0
if self.flag1 == 2:
try:
self.parametersPanel.txtMoc.setText(
str(
round(
Unit.ConvertFeetToMeter(
float(self.parametersPanel.txtMocFt.text())),
4)))
except:
self.parametersPanel.txtMoc.setText("0.0")
def iasChanged(self):
try:
self.parametersPanel.txtTas.setText(
str(
round(
Speed.smethod_0(
Speed(float(self.parametersPanel.txtIas.text())),
float(self.parametersPanel.txtIsa.text()),
Altitude(
float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)).Knots, 4)))
except:
raise ValueError("Value Invalid")
def isaChanged(self):
try:
self.parametersPanel.txtTas.setText(
str(
round(
Speed.smethod_0(
Speed(float(self.parametersPanel.txtIas.text())),
float(self.parametersPanel.txtIsa.text()),
Altitude(
float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)).Knots, 4)))
except:
raise ValueError("Value Invalid")
def iasHelpShow(self):
dlg = IasHelpDlg()
dlg.exec_()
def changeCategory(self):
if self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.A:
self.parametersPanel.txtIas.setText(str(Speed(150).Knots))
return
elif self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.B:
self.parametersPanel.txtIas.setText(str(Speed(180).Knots))
return
elif self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.C:
self.parametersPanel.txtIas.setText(str(Speed(240).Knots))
return
elif self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.D:
self.parametersPanel.txtIas.setText(str(Speed(250).Knots))
return
elif self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.E:
self.parametersPanel.txtIas.setText(str(Speed(250).Knots))
return
elif self.parametersPanel.cmbAircraftCategory_2.currentIndex(
) == AircraftSpeedCategory.H:
self.parametersPanel.txtIas.setText(str(Speed(250).Knots))
return
def method_31(self):
self.parametersPanel.pnlWind.setAltitude(
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT))
try:
speed = Speed.smethod_0(
Speed(float(self.parametersPanel.txtIas.text())),
float(self.parametersPanel.txtIsa.text()),
Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT))
self.parametersPanel.txtTas.setText(str(round(speed.Knots, 4)))
except:
raise ValueError("Value Invalid")
# def captureBearing(self):
# self.captureTrackTool= CaptureBearingTool(define._canvas, self.parametersPanel.txtTrack)
# define._canvas.setMapTool(self.captureTrackTool)
def method_36(self, bool_0):
polylines = []
point3d5 = self.parametersPanel.pnlWaypoint.Point3d
value = float(self.parametersPanel.txtTrack.Value)
value1 = float(self.parametersPanel.txtRnpValue.text())
speed = Speed(float(self.parametersPanel.txtIas.text()))
altitude = Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)
num1 = float(self.parametersPanel.txtIsa.text())
value2 = float(self.parametersPanel.txtTime.text())
speed1 = Speed(float(self.parametersPanel.pnlWind.speedBox.text()))
num = 15 if (altitude.Feet >= 24500) else 23
speed2 = Speed.smethod_0(speed, num1, altitude)
metresPerSecond = value2 * 60 * speed2.MetresPerSecond
num2 = math.pow(speed2.Knots + speed1.Knots, 2) / (
34313 * math.tan(Unit.ConvertDegToRad(num))) * 1852
num3 = value1 * 1852
num4 = num2 * (1 - math.sin(Unit.ConvertDegToRad(20))) / (
2 * math.cos(Unit.ConvertDegToRad(20)))
num5 = value1 * 1852 + 3704
if (num5 < 9260):
num5 = 9260
point3d4 = MathHelper.distanceBearingPoint(
point3d5, Unit.ConvertDegToRad(value + 90), num2 /
2) if (self.parametersPanel.cmbOrientation.currentText() !=
OrientationType.Left) else MathHelper.distanceBearingPoint(
point3d5, Unit.ConvertDegToRad(value - 90), num2 / 2)
point3d6 = MathHelper.distanceBearingPoint(point3d4,
Unit.ConvertDegToRad(value),
num4)
point3d7 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value + 180), metresPerSecond)
num6 = num2 / 2 + 1.414 * num3
num7 = num2 / 2 + num3
point3d8 = MathHelper.distanceBearingPoint(point3d6,
Unit.ConvertDegToRad(value),
num6)
point3d9 = MathHelper.distanceBearingPoint(
point3d6,
Unit.ConvertDegToRad(value + 90) - math.acos(num7 / num6), num6)
point3d10 = MathHelper.distanceBearingPoint(
point3d7,
Unit.ConvertDegToRad(value + 90) + math.acos(num7 / num6), num6)
point3d11 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value + 180), num6)
point3d12 = MathHelper.distanceBearingPoint(
point3d7,
Unit.ConvertDegToRad(value - 90) - math.acos(num7 / num6), num6)
point3d13 = MathHelper.distanceBearingPoint(
point3d6,
Unit.ConvertDegToRad(value - 90) + math.acos(num7 / num6), num6)
point3d = MathHelper.getIntersectionPoint(
point3d9,
MathHelper.distanceBearingPoint(
point3d9,
MathHelper.getBearing(point3d6, point3d9) -
Unit.ConvertDegToRad(90), 100), point3d8,
MathHelper.distanceBearingPoint(point3d8,
Unit.ConvertDegToRad(value + 90),
100))
point3d1 = MathHelper.getIntersectionPoint(
point3d10,
MathHelper.distanceBearingPoint(
point3d10,
MathHelper.getBearing(point3d7, point3d10) +
Unit.ConvertDegToRad(90), 100), point3d11,
MathHelper.distanceBearingPoint(point3d11,
Unit.ConvertDegToRad(value + 90),
100))
point3d2 = MathHelper.getIntersectionPoint(
point3d12,
MathHelper.distanceBearingPoint(
point3d12,
MathHelper.getBearing(point3d7, point3d12) -
Unit.ConvertDegToRad(90), 100), point3d11,
MathHelper.distanceBearingPoint(point3d11,
Unit.ConvertDegToRad(value - 90),
100))
point3d3 = MathHelper.getIntersectionPoint(
point3d13,
MathHelper.distanceBearingPoint(
point3d13,
MathHelper.getBearing(point3d6, point3d13) +
Unit.ConvertDegToRad(90), 100), point3d8,
MathHelper.distanceBearingPoint(point3d8,
Unit.ConvertDegToRad(value - 90),
100))
polylines1 = []
if (bool_0):
num8 = num2 / 2
point3d14 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value + 90), num8)
point3d15 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value + 90), num8)
point3d16 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value - 90), num8)
point3d17 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value - 90), num8)
point3dArray = [point3d14, point3d15, point3d16, point3d17]
polylineArea = PolylineArea(point3dArray)
polylineArea.method_19(
1, -1
) #MathHelper.smethod_57(TurnDirection.Right, point3d15, point3d16, point3d7))
polylineArea.method_19(
3, -1
) #MathHelper.smethod_57(TurnDirection.Right, point3d17, point3d14, point3d4))
polylines1.append(polylineArea)
point3dArray1 = [point3d9, point3d10, point3d12, point3d13]
polylineArea1 = PolylineArea(point3dArray1)
# for point3d0 in point3dArray1:
# polyline1.Add(point3d0)
polylineArea1.method_19(
1,
MathHelper.smethod_57(TurnDirection.Right, point3d10, point3d12,
point3d7))
polylineArea1.method_19(
3,
MathHelper.smethod_57(TurnDirection.Right, point3d13, point3d9,
point3d6))
# polylineArea1.set_closed(True)
# polyline1.SetDatabaseDefaults();
polylines1.append(polylineArea1)
num9 = num5 / 5
for i in range(1, 6):
# polylineArea1.pop(len(polylineArea1) -1)
polylineArea0 = polylineArea1.getOffsetCurve(num9 * i, 4)
polylines1.append(polylineArea0)
return polylines1
def method_36_Construct(self, bool_0):
polylines = []
point3d5 = self.parametersPanel.pnlWaypoint.Point3d
value = float(self.parametersPanel.txtTrack.Value)
value1 = float(self.parametersPanel.txtRnpValue.text())
speed = Speed(float(self.parametersPanel.txtIas.text()))
altitude = Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT)
num1 = float(self.parametersPanel.txtIsa.text())
value2 = float(self.parametersPanel.txtTime.text())
speed1 = Speed(float(self.parametersPanel.pnlWind.speedBox.text()))
num = 15 if (altitude.Feet >= 24500) else 23
speed2 = Speed.smethod_0(speed, num1, altitude)
metresPerSecond = value2 * 60 * speed2.MetresPerSecond
num2 = math.pow(speed2.Knots + speed1.Knots, 2) / (
34313 * math.tan(Unit.ConvertDegToRad(num))) * 1852
num3 = value1 * 1852
num4 = num2 * (1 - math.sin(Unit.ConvertDegToRad(20))) / (
2 * math.cos(Unit.ConvertDegToRad(20)))
num5 = value1 * 1852 + 3704
if (num5 < 9260):
num5 = 9260
point3d4 = MathHelper.distanceBearingPoint(
point3d5, Unit.ConvertDegToRad(value + 90), num2 /
2) if (self.parametersPanel.cmbOrientation.currentText() !=
OrientationType.Left) else MathHelper.distanceBearingPoint(
point3d5, Unit.ConvertDegToRad(value - 90), num2 / 2)
point3d6 = MathHelper.distanceBearingPoint(point3d4,
Unit.ConvertDegToRad(value),
num4)
point3d7 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value + 180), metresPerSecond)
num6 = num2 / 2 + 1.414 * num3
num7 = num2 / 2 + num3
point3d8 = MathHelper.distanceBearingPoint(point3d6,
Unit.ConvertDegToRad(value),
num6)
point3d9 = MathHelper.distanceBearingPoint(
point3d6,
Unit.ConvertDegToRad(value + 90) - math.acos(num7 / num6), num6)
point3d10 = MathHelper.distanceBearingPoint(
point3d7,
Unit.ConvertDegToRad(value + 90) + math.acos(num7 / num6), num6)
point3d11 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value + 180), num6)
point3d12 = MathHelper.distanceBearingPoint(
point3d7,
Unit.ConvertDegToRad(value - 90) - math.acos(num7 / num6), num6)
point3d13 = MathHelper.distanceBearingPoint(
point3d6,
Unit.ConvertDegToRad(value - 90) + math.acos(num7 / num6), num6)
point3d = MathHelper.getIntersectionPoint(
point3d9,
MathHelper.distanceBearingPoint(
point3d9,
MathHelper.getBearing(point3d6, point3d9) -
Unit.ConvertDegToRad(90), 100), point3d8,
MathHelper.distanceBearingPoint(point3d8,
Unit.ConvertDegToRad(value + 90),
100))
point3d1 = MathHelper.getIntersectionPoint(
point3d10,
MathHelper.distanceBearingPoint(
point3d10,
MathHelper.getBearing(point3d7, point3d10) +
Unit.ConvertDegToRad(90), 100), point3d11,
MathHelper.distanceBearingPoint(point3d11,
Unit.ConvertDegToRad(value + 90),
100))
point3d2 = MathHelper.getIntersectionPoint(
point3d12,
MathHelper.distanceBearingPoint(
point3d12,
MathHelper.getBearing(point3d7, point3d12) -
Unit.ConvertDegToRad(90), 100), point3d11,
MathHelper.distanceBearingPoint(point3d11,
Unit.ConvertDegToRad(value - 90),
100))
point3d3 = MathHelper.getIntersectionPoint(
point3d13,
MathHelper.distanceBearingPoint(
point3d13,
MathHelper.getBearing(point3d6, point3d13) +
Unit.ConvertDegToRad(90), 100), point3d8,
MathHelper.distanceBearingPoint(point3d8,
Unit.ConvertDegToRad(value - 90),
100))
polylines1 = []
polylineArea = None
if (bool_0):
num8 = num2 / 2
point3d14 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value + 90), num8)
point3d15 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value + 90), num8)
point3d16 = MathHelper.distanceBearingPoint(
point3d7, Unit.ConvertDegToRad(value - 90), num8)
point3d17 = MathHelper.distanceBearingPoint(
point3d4, Unit.ConvertDegToRad(value - 90), num8)
point3dArray = [point3d14, point3d15, point3d16, point3d17]
polylineArea = PolylineArea(point3dArray)
polylineArea.method_19(
1, -1
) #MathHelper.smethod_57(TurnDirection.Right, point3d15, point3d16, point3d7))
polylineArea.method_19(
3, -1
) #MathHelper.smethod_57(TurnDirection.Right, point3d17, point3d14, point3d4))
polylines1.append(polylineArea)
point3dArray1 = [point3d9, point3d10, point3d12, point3d13]
polylineArea1 = PolylineArea(point3dArray1)
# for point3d0 in point3dArray1:
# polyline1.Add(point3d0)
polylineArea1.method_19(
1,
MathHelper.smethod_57(TurnDirection.Right, point3d10, point3d12,
point3d7))
polylineArea1.method_19(
3,
MathHelper.smethod_57(TurnDirection.Right, point3d13, point3d9,
point3d6))
# polylineArea1.set_closed(True)
# polyline1.SetDatabaseDefaults();
polylines1.append(polylineArea1)
polylineAreaLineList = [
PolylineArea(
[polylineArea1[0].Position, polylineArea1[1].Position]),
PolylineArea(
[polylineArea1[2].Position, polylineArea1[3].Position])
]
polylineAreaArc0 = PolylineArea()
polylineAreaArc0.Add(polylineArea1[1])
polylineAreaArc0.Add(PolylineAreaPoint(polylineArea1[2].Position))
polylineAreaArc1 = PolylineArea()
polylineAreaArc1.Add(polylineArea1[3])
polylineAreaArc1.Add(PolylineAreaPoint(polylineArea1[0].Position))
polylineAreaArcList = [polylineAreaArc0, polylineAreaArc1]
num9 = num5 / 5
polylineAreaArcListResult = []
polylineAreaLineListResult = []
for i in range(1, 6):
polylineAreaL0 = polylineAreaLineList[0].getOffsetCurveNo(
num9 * i, 4)
polylineAreaLineListResult.append(polylineAreaL0)
polylineAreaA0 = polylineAreaArcList[0].getOffsetCurveNo(
num9 * i, 4)
polylineAreaT = PolylineArea()
polylineAreaT.Add(
PolylineAreaPoint(
polylineAreaA0[0].Position,
MathHelper.smethod_60(
polylineAreaA0[0].Position,
polylineAreaA0[int(len(polylineAreaA0) / 2)].Position,
polylineAreaA0[len(polylineAreaA0) - 1].Position)))
polylineAreaT.Add(
PolylineAreaPoint(polylineAreaA0[len(polylineAreaA0) -
1].Position))
polylineAreaArcListResult.append(polylineAreaT)
polylineAreaL1 = polylineAreaLineList[1].getOffsetCurveNo(
num9 * i, 4)
polylineAreaLineListResult.append(polylineAreaL1)
polylineAreaA1 = polylineAreaArcList[1].getOffsetCurveNo(
num9 * i, 4)
polylineAreaT = PolylineArea()
polylineAreaT.Add(
PolylineAreaPoint(
polylineAreaA1[0].Position,
MathHelper.smethod_60(
polylineAreaA1[0].Position,
polylineAreaA1[int(len(polylineAreaA1) / 2)].Position,
polylineAreaA1[len(polylineAreaA1) - 1].Position)))
polylineAreaT.Add(
PolylineAreaPoint(polylineAreaA1[len(polylineAreaA1) -
1].Position))
polylineAreaArcListResult.append(polylineAreaT)
polylineAreaLineListResult.append(
PolylineArea([
polylineAreaL0[len(polylineAreaL0) - 1].Position,
polylineAreaA0[0].Position
]))
polylineAreaLineListResult.append(
PolylineArea([
polylineAreaA0[len(polylineAreaA0) - 1].Position,
polylineAreaL1[0].Position
]))
polylineAreaLineListResult.append(
PolylineArea([
polylineAreaL1[len(polylineAreaL1) - 1].Position,
polylineAreaA1[0].Position
]))
polylineAreaLineListResult.append(
PolylineArea([
polylineAreaA1[len(polylineAreaA1) - 1].Position,
polylineAreaL0[0].Position
]))
return polylineAreaLineListResult, polylineAreaArcListResult, polylineArea
class OptionsLayout(QTabWidget):
''' Manages right panel.
Provides general informations, navigation and timestamp selection.
Navigation allow user to zoom in timeline.
Timestamp selection allow user to select which timestamp to display with
which color.
'''
def __init__(self, parent):
QTabWidget.__init__(self)
self.setTabPosition(QTabWidget.East)
self.init(parent)
self.initShape()
def init(self, parent):
self.VFS = libvfs.VFS.Get()
self.timeline = parent
self.swapIndex = -1
self.swapColor = ''
self.metricIndex = -1
self.configuration = []
self.zoom = False
self.exportedNode = None
def initShape(self):
self.h = QHBoxLayout()
self.vbox = QVBoxLayout()
self.vbox.setMargin(0)
self.vbox.setSpacing(0)
self.vbox.setAlignment(Qt.AlignTop)
self.setLayout(self.vbox)
self.infoBox = QGroupBox('Global information')
# self.infoBox.setFlat(True)
self.totalNodes = QLabel('No time found in nodes')
self.startTime = QLabel('No start time')
self.endTime = QLabel('No end time')
self.navBox = QGroupBox('Navigation')
self.selStartTime = QLabel('No selection start time')
self.selEndTime = QLabel('No selection end time')
self.buttonLayout = QHBoxLayout()
self.zoomButton = QPushButton('Zoom')
self.zoomButton.setEnabled(False)
self.zoomButton.connect(self.zoomButton, SIGNAL("clicked(bool)"), self.zoomClick)
self.dezoomButton = QPushButton('Original Size')
self.dezoomButton.setEnabled(False)
self.dezoomButton.connect(self.dezoomButton, SIGNAL("clicked(bool)"), self.dezoomClick)
self.exportButton = QPushButton('Export')
self.exportButton.setEnabled(False)
self.exportButton.connect(self.exportButton, SIGNAL("clicked(bool)"), self.exportClick)
self.buttonLayout.setAlignment(Qt.AlignLeft)
self.buttonLayout.addWidget(self.zoomButton)
self.buttonLayout.addWidget(self.dezoomButton)
self.selectedNodes = QLabel('Nothing selected')
self.infoLayout = QVBoxLayout()
self.infoLayout.setAlignment(Qt.AlignTop)
self.infoLayout.addWidget(self.totalNodes)
self.infoLayout.addWidget(self.startTime)
self.infoLayout.addWidget(self.endTime)
self.infoBox.setLayout(self.infoLayout)
self.navLayout = QVBoxLayout()
self.navLayout.setAlignment(Qt.AlignTop)
self.navLayout.addWidget(self.selStartTime)
self.navLayout.addWidget(self.selEndTime)
self.navLayout.addLayout(self.buttonLayout)
self.navLayout.addWidget(self.selectedNodes)
self.navLayout.addWidget(self.exportButton)
self.navBox.setLayout(self.navLayout)
self.familyLayout = QVBoxLayout()
self.familyLayout.setMargin(0)
self.familyLayout.setSpacing(0)
self.familyWidget = QWidget()
self.familyWidget.setLayout(self.familyLayout)
self.familyScroll = QScrollArea()
self.insertTab(0, self.infoBox, 'Global')
self.insertTab(1, self.navBox, 'Navigation')
self.insertTab(2, self.familyScroll, 'Display')
def newInformations(self):
if self.timeline.timesCount > 1:
sTimes = str(self.timeline.timesCount) + ' time values'
else:
sTimes = 'One time value'
if self.timeline.nodeCount > 1:
sNodes = str(self.timeline.nodeCount) + ' nodes'
else:
sNodes = 'one node'
self.totalNodes.setText(sTimes + '\n' + sNodes)
if self.timeline.baseDateMin != self.timeline.dateMin:
self.startTime.setText('From ' + str(self.timeline.fromUSec(self.timeline.baseDateMin).strftime('%d.%m.%Y %H:%M:%S')))
if self.timeline.selDateMin:
self.selStartTime.setText('From ' + str(self.timeline.fromUSec(self.timeline.selDateMin).strftime('%d.%m.%Y %H:%M:%S')))
else:
self.selStartTime.setText('No selection start time')
if self.timeline.baseDateMax != self.timeline.dateMax:
self.endTime.setText('To ' + str(self.timeline.fromUSec(self.timeline.baseDateMax).strftime('%d.%m.%Y %H:%M:%S')))
if self.timeline.selDateMax:
self.selEndTime.setText('To ' + str(self.timeline.fromUSec(self.timeline.selDateMax).strftime('%d.%m.%Y %H:%M:%S')))
else:
self.selEndTime.setText('No selection end time')
def dumpOptionsConf(self):
for family in self.configuration:
if not family[1]:
print family[0] + ': empty'
else:
print family[0] + ':'
for time in family[1]:
print '\t' + time[0] + ':'
for param in time[1]:
print '\t\t' + param[0] + ':', param[1]
def createMetricTools(self):
'''
Called once countThread is over.
'''
if not self.configuration:
# First, create configuration dictionary
i = 0
for timeFamily, timeList in self.timeline.timeMap.items():
if len(timeList):
# One sub dictionary per time family
self.configuration.append([timeFamily, []])
for oneMetric in timeList:
# One sub sub dictionary per family sub time
# checked indicate if item is displayed
# color indicate which color to use
if i < len(self.timeline.colors):
self.configuration[-1][1].append([oneMetric, [['checked', True],
['color', self.timeline.colors[i][0]],
['checkBox', None],
['colorWidget', None],
['colorWidgetIndex', -1],
['orderedNodeList', {'dates':None, 'nodes':None}],
['dateLimits', [long(0), long(0xffffffffffffffff)]],
['mainPixmap', [True, None]],
['zoomPixmap', [True, None]]]])
else:
self.configuration[-1][1].append([oneMetric, [['checked', False],
['color', ''],
['checkBox', None],
['colorWidget', None],
['colorWidgetIndex', -1],
['orderedNodeList', {'dates':None, 'nodes':None}],
['dateLimits', [long(0), long(0xffffffffffffffff)]],
['mainPixmap', [True, None]],
['zoomPixmap', [True, None]]]])
i += 1
else:
self.configuration.append([timeFamily, []])
# Configuration object created, now create graphical view of it
# self.dumpOptionsConf()
i = 0
for family in self.configuration:
if family[1]:
box = QGroupBox(family[0])
oneTime = QVBoxLayout()
for time in family[1]:
hbox = QHBoxLayout()
time[1][2][1] = QCheckBox(':'.join(time[0]))
self.connect(time[1][2][1], SIGNAL("stateChanged(int)"), self.checkboxClick)
time[1][3][1] = QComboBox()
for color in self.timeline.colors:
time[1][3][1].addItem(color[0])
palette = time[1][2][1].palette()
if i < len(self.timeline.colors):
time[1][2][1].setChecked(time[1][0][1])
# Colorize foreground
palette.setColor(QPalette.WindowText, self.timeline.colors[i][1])
time[1][3][1].setCurrentIndex(i)
time[1][4][1] = i
else:
# In case every colors are already used, don't check time (default) and don't select any color
palette.setColor(QPalette.WindowText, Qt.gray)
time[1][0][1] = False
time[1][3][1].setEnabled(False)
time[1][2][1].setPalette(palette)
self.connect(time[1][3][1], SIGNAL("currentIndexChanged(const QString&)"), self.colorChange)
hbox.addWidget(time[1][2][1])
hbox.addWidget(time[1][3][1])
oneTime.addLayout(hbox)
i += 1
box.setLayout(oneTime)
optimum = box.minimumSizeHint()
box.setFixedSize(optimum)
if optimum.width() > self.familyLayout.sizeHint().width():
geom = QRect(0, 0, optimum.width(), self.familyLayout.sizeHint().height() + optimum.height())
else:
geom = QRect(0, 0, self.familyLayout.sizeHint().width(), self.familyLayout.sizeHint().height() + optimum.height())
self.familyLayout.addWidget(box)
self.familyLayout.setGeometry(geom)
self.familyWidget.setFixedSize(geom.width(), geom.height())
self.familyScroll.setWidget(self.familyWidget)
else:
# Configuration object already created, we are called because am item has been
# unchecked or its color has changed.
pass
def colorChange(self, colorText):
loop = 2
while loop:
i = 0
for family in self.configuration:
for time in family[1]:
if time[1][3][1]:
if QString(time[1][1][1]) != time[1][3][1].currentText() and self.swapIndex == -1 and self.metricIndex == -1 and time[1][3][1].isEnabled():
# This selection has just been changed
self.swapColor = time[1][1][1]
self.swapIndex = time[1][4][1]
time[1][1][1] = str(colorText)
#Color
palette = time[1][2][1].palette()
palette.setColor(QPalette.WindowText, self.timeline.colors[time[1][3][1].currentIndex()][1])
time[1][2][1].setPalette(palette)
time[1][4][1] = time[1][3][1].currentIndex()
time[1][7][1][0] = True
time[1][8][1][0] = True
self.metricIndex = i
if QString(time[1][1][1]) == colorText and self.swapIndex != -1 and self.metricIndex != i and time[1][3][1].isEnabled():
# This selection is impacted because color is the same as the one just selected
# Changing color relaunch another signal.
time[1][1][1] = self.swapColor
time[1][4][1] = self.swapIndex
time[1][3][1].setCurrentIndex(self.swapIndex)
time[1][7][1][0] = True
time[1][8][1][0] = True
#Color
palette = time[1][2][1].palette()
palette.setColor(QPalette.WindowText, self.timeline.colors[time[1][3][1].currentIndex()][1])
time[1][2][1].setPalette(palette)
self.metricIndex = -1
i += 1
loop -= 1
# if self.swapColor == '':
# Swap already done ; redraw
self.timeline.updatePaintingArea()
self.swapIndex = -1
self.swapColor = ''
self.metricIndex = -1
def checkboxClick(self, newState):
self.selectedNodes.setText('Nothing selected')
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
for family in self.configuration:
for time in family[1]:
if time[1][2][1]:
palette = time[1][2][1].palette()
if not time[1][2][1].checkState() and time[1][0][1]:
# This box has just been unchecked
time[1][0][1] = False
time[1][3][1].setEnabled(False)
palette.setColor(QPalette.WindowText, Qt.gray)
elif time[1][2][1].checkState() and not time[1][0][1]:
# This box has just been checked
time[1][0][1] = True
time[1][3][1].setEnabled(True)
# Deactivate color already used
palette.setColor(QPalette.WindowText, self.timeline.colors[time[1][3][1].currentIndex()][1])
time[1][1][1] = self.timeline.colors[time[1][3][1].currentIndex()][0]
time[1][4][1] = time[1][3][1].currentIndex()
time[1][7][1][0] = True
time[1][8][1][0] = True
for family2 in self.configuration:
# sure, 2 is ugly, it is used to search color to remove
for time2 in family2[1]:
if time2[1][3][1] and time2[1][3][1].isEnabled():
if self.timeline.colors[time2[1][3][1].currentIndex()][0] == self.timeline.colors[time[1][3][1].currentIndex()][0] and time2[1][3][1] != time[1][3][1]:
palette2 = time2[1][2][1].palette()
time2[1][0][1] = False
time2[1][2][1].setChecked(False)
time2[1][3][1].setEnabled(False)
palette2.setColor(QPalette.WindowText, Qt.gray)
time2[1][2][1].setPalette(palette2)
time[1][2][1].setPalette(palette)
self.timeline.updatePaintingArea()
def zoomClick(self, clickState):
self.timeline.maxOccZoom = 0
rect = self.timeline.ploter.selectionRect.rect()
newSelDateMin = self.timeline.draw.findXTime(rect.x())
newSelDateMax = self.timeline.draw.findXTime(rect.x() + rect.width())
self.timeline.selDateMin = self.timeline.toUSec(newSelDateMin)
self.timeline.selDateMax = self.timeline.toUSec(newSelDateMax)
self.newInformations()
self.dezoomButton.setEnabled(True)
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
txt = self.selectedNodes.text().__str__()
self.selectedNodes.setText(txt[:txt.rfind(' ')] + ' displayed')
self.zoom = True
self.timeline.updatePaintingArea(True)
def dezoomClick(self, clickState):
self.dezoomButton.setEnabled(False)
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
self.zoom = False
self.timeline.selDateMin = None
self.timeline.selDateMax = None
self.timeline.maxOccZoom = 0
self.newInformations()
for family in self.configuration:
for time in family[1]:
if time[1][8][1]:
time[1][8][1][0] = True
time[1][8][1][1] = None
self.timeline.updatePaintingArea()
def exportClick(self, clickState):
rect = self.timeline.ploter.selectionRect.rect()
exportSelDateMin = self.timeline.draw.findXTime(rect.x())
exportSelDateMax = self.timeline.draw.findXTime(rect.x() + rect.width())
for family in self.configuration:
for time in family[1]:
if time[1][0][1]:
nodes = []
everyNodes = self.timeline.elementsInRangeToNodeList(time[1][5][1], self.timeline.toUSec(exportSelDateMin), self.timeline.toUSec(exportSelDateMax))
for oneGroupNode in everyNodes:
for node in oneGroupNode:
nodes.append(node)
if len(nodes):
if not self.exportedNode:
# Create /timeline if needed
root = vfs.vfs().getnode('/Bookmarks')
baseNode = Node('timeline', 0, root)
baseNode.__disown__()
baseNode.setDir()
e = event()
e.thisown = False
e.value = RCVariant(Variant(baseNode))
self.VFS.notify(e)
# Create /timeline/<ParentName>
self.exportedNode = Node(self.timeline.node.name(), 0, baseNode)
self.exportedNode.__disown__()
self.exportedNode.setDir()
timeBaseName = self.exportedNode.absolute() + '/' + str(exportSelDateMin.strftime('%d.%m.%Y %H:%M:%S')) + ' to ' + str(exportSelDateMax.strftime('%d.%m.%Y %H:%M:%S'))
timeBaseNode = vfs.vfs().getnode(timeBaseName)
if not timeBaseNode:
# Create /timeline/<ParentName>/dateStart to dateEnd/<Module:FullTimestampAttributePath>/
timeBaseNode = Node(str(exportSelDateMin.strftime('%d.%m.%Y %H:%M:%S')) + ' to ' + str(exportSelDateMax.strftime('%d.%m.%Y %H:%M:%S')), 0, self.exportedNode)
timeBaseNode.__disown__()
timeBaseNode.setDir()
baseFamilyName = timeBaseNode.absolute() + '/' + ':'.join([family[0]] + time[0])
baseFamilyNode = vfs.vfs().getnode(baseFamilyName)
if not baseFamilyNode:
# Create /timeline/<ParentName>/dateStart to dateEnd//<Module:FullTimestampAttributePath> if needed
baseFamilyNode = Node(':'.join([family[0]] + time[0]), 0, timeBaseNode)
baseFamilyNode.__disown__()
baseFamilyNode.setDir()
for node in nodes:
# Add each node in array as child
l = VLink(node, baseFamilyNode)
l.__disown__()
def __init__(self):
super(PhotoWindow, self).__init__()
self.path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
self.viewer = PhotosViewer(self)
self.setWindowTitle('Photo')
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setWindowIcon(QIcon(self.path + "//icon.png"))
self.infoPhoto1 = QLineEdit(self)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self.infoPhoto1.setSizePolicy(sizePolicy)
self.infoPhoto1.setFrame(True)
self.infoPhoto1.setReadOnly(True)
self.infoPhoto1.setMouseTracking(False)
self.infoPhoto2 = QLineEdit(self)
self.infoPhoto2.setSizePolicy(sizePolicy)
self.infoPhoto2.setFrame(True)
self.infoPhoto2.setReadOnly(True)
self.infoPhoto2.setMouseTracking(False)
self.infoPhoto3 = QLineEdit(self)
self.infoPhoto3.setSizePolicy(sizePolicy)
self.infoPhoto3.setFrame(True)
self.infoPhoto3.setReadOnly(True)
self.infoPhoto3.setMouseTracking(False)
self.extent = QPushButton(self)
self.extent.setSizePolicy(sizePolicy)
self.extent.setCheckable(True)
self.extent.setChecked(True)
self.extent.setIcon(
QIcon(self.path + '//svg//mActionZoomFullExtent.svg'))
self.extent.clicked.connect(self.extentbutton)
self.zoom = QPushButton(self)
self.zoom.setSizePolicy(sizePolicy)
self.zoom.setCheckable(True)
self.zoom.setChecked(False)
self.zoom.setIcon(QIcon(self.path + '//svg//mActionZoomIn.svg'))
self.zoom.clicked.connect(self.zoombutton)
self.pan = QPushButton(self)
self.pan.setSizePolicy(sizePolicy)
self.pan.setCheckable(True)
self.pan.setChecked(False)
self.pan.setIcon(QIcon(self.path + '//svg//mActionPan.svg'))
self.pan.clicked.connect(self.panbutton)
# Arrange layout
VBlayout = QVBoxLayout(self)
HBlayout = QHBoxLayout()
VBlayout.addWidget(self.viewer)
HBlayout.setAlignment(Qt.AlignCenter)
HBlayout.addWidget(self.infoPhoto1)
HBlayout.addWidget(self.infoPhoto2)
HBlayout.addWidget(self.infoPhoto3)
HBlayout.addWidget(self.extent)
HBlayout.addWidget(self.zoom)
HBlayout.addWidget(self.pan)
VBlayout.addLayout(HBlayout)
class TestSliders(QWidget):
def __init__(self, obj = None, parent= None):
QWidget.__init__(self, parent)
self.obj = obj
self.Parent = parent
self.wV = QWidget(self)
self.wH = QWidget(self)
self.setTestWidgetsSize()
self.testVSlider1 = QSlider()
self.testVSlider1.setOrientation(Qt.Vertical)
self.testVSlider2 = QSlider()
self.testVSlider2.setOrientation(Qt.Vertical)
self.testVSlider3 = QSlider()
self.testVSlider3.setOrientation(Qt.Vertical)
self.testHSlider1 = QSlider()
self.testHSlider1.setOrientation(Qt.Horizontal)
self.testHSlider2 = QSlider()
self.testHSlider2.setOrientation(Qt.Horizontal)
self.testHSlider3 = QSlider()
self.testHSlider3.setOrientation(Qt.Horizontal)
self.setSlidersStyleSheet()
self.commonLayout = QHBoxLayout()
self.commonLayout.setSpacing(0)
self.vertLayout = QVBoxLayout()
self.vertLayout.setAlignment(Qt.AlignCenter)
self.vertLayout.setSpacing(0)
self.vertLayout.setContentsMargins(0,0,0,0)
self.vertLayout.addWidget(self.testHSlider1)
self.vertLayout.addWidget(self.testHSlider2)
self.vertLayout.addWidget(self.testHSlider3)
self.wV.setLayout(self.vertLayout)
self.hrznLayout = QHBoxLayout()
self.hrznLayout.setAlignment(Qt.AlignCenter)
self.hrznLayout.setSpacing(0)
self.hrznLayout.setContentsMargins(0,0,0,0)
self.hrznLayout.addWidget(self.testVSlider1)
self.hrznLayout.addWidget(self.testVSlider2)
self.hrznLayout.addWidget(self.testVSlider3)
self.wH.setLayout(self.hrznLayout)
self.clearChanges = QPushButton(QIcon().fromTheme('view-refresh'), "Clear")
self.clearChanges.clicked.connect(self.clearSlidersChanges)
self.commonLayout.addWidget(self.wV)
self.commonLayout.addWidget(self.wH)
self.commonLayout.addWidget(self.clearChanges)
self.setLayout(self.commonLayout)
def setSlidersSize(self, v1, v2, v3, v4, get_Style = None):
if get_Style is None :
styleHSheet, styleVSheet = STYLE_HORYZ, STYLE_VERT
elif type(get_Style)==tuple :
styleHSheet, styleVSheet = get_Style
styleHSheet = styleHSheet.replace("__MARGIN__", v1)
styleVSheet = styleVSheet.replace("__MARGIN__", v1)
styleHSheet = styleHSheet.replace("__THICK__", v2)
styleVSheet = styleVSheet.replace("__THICK__", v2)
styleHSheet = styleHSheet.replace("__HTHICK__", v3)
styleVSheet = styleVSheet.replace("__HTHICK__", v3)
styleHSheet = styleHSheet.replace("__HLEDGE__", v4)
styleVSheet = styleVSheet.replace("__HLEDGE__", v4)
return styleHSheet, styleVSheet
def setSlidersColor(self, v1, v2, v3, get_Style = None):
if get_Style is None :
styleHSheet, styleVSheet = STYLE_HORYZ, STYLE_VERT
elif type(get_Style)==tuple :
styleHSheet, styleVSheet = get_Style
styleHSheet = styleHSheet.replace("#FFF777", v1)
styleVSheet = styleVSheet.replace("#FFF777", v1)
styleHSheet = styleHSheet.replace("#2277FF", v2)
styleVSheet = styleVSheet.replace("#2277FF", v2)
styleHSheet = styleHSheet.replace("#CCCCCC", v3)
styleVSheet = styleVSheet.replace("#CCCCCC", v3)
return styleHSheet, styleVSheet
def _setSlidersStyleSheet(self, h, v):
self.testHSlider1.setStyleSheet(h)
self.testHSlider2.setStyleSheet(h)
self.testHSlider3.setStyleSheet(h)
self.testVSlider1.setStyleSheet(v)
self.testVSlider2.setStyleSheet(v)
self.testVSlider3.setStyleSheet(v)
def setSlidersStyleSheet(self, mark = None):
if mark is None :
if hasattr(self.obj, 'sizeSelect') and \
hasattr(self.obj, 'colorSelect') :
get_Style = self.obj.sizeSelect.setSlidersSize()
h, v = self.obj.colorSelect.setSlidersColor(get_Style)
self._setSlidersStyleSheet(h, v)
else :
self._setSlidersStyleSheet(self.obj.style_horiz, self.obj.style_vert)
elif not mark :
get_Style = self.obj.colorSelect.setSlidersColor()
h, v = self.obj.sizeSelect.setSlidersSize(get_Style)
self._setSlidersStyleSheet(h, v)
self.obj.sizeSelect.testSliders._setSlidersStyleSheet(h, v)
def clearSlidersChanges(self):
if self.Parent == self.obj.sizeSelect :
self.Parent.restoreValues()
if self.Parent == self.obj.colorSelect :
self.Parent.restoreValues()
self.setSlidersStyleSheet(False)
self.Parent.restoreValues()
self.setSlidersStyleSheet(False)
def setTestWidgetsSize(self):
size = self.obj.size()
if not size.isValid() : return
if self.Parent.Settings.value('Vertical::widgetOrientation').toString() == '1':
parameter = size.width()
else :
parameter = size.height()
self.wV.setFixedWidth(parameter)
self.wH.setFixedHeight(parameter)
self.Parent.updateGeometry()
def genOneTab(self, tabtitle="", tabbtn="", tabnums="", strwhere = "where studentsn like '03%' "):
# tabtitle.setFixedHeight(40)
# tabtitle.setFixedWidth(160)
tabtitle.setFont(QFont('Courier New', 20))
tabtitle.setText("随堂提问演板")
tabtitle.setStyleSheet("border: 1px solid blue; color:rgba(0,0,255, 220);\
background-color:rgba(201,201,201,60);\
border-radius: 6px; \
padding: 1px 18px 1px 20px;\
min-width: 8em;")
tabtitle.setMinimumHeight(50);
titleLayout = QHBoxLayout()
titleLayout.addWidget(tabtitle)
titleLayout.setAlignment(tabtitle, Qt.AlignCenter)
btnlayout = QGridLayout()
cur = conn.cursor()
strsql = "select studentsn, studentname from student " + strwhere
cur.execute(strsql)
tmpnum = 0
for item in cur.fetchall():
irow = tmpnum // 7
icol = tmpnum % 7
tmpnum += 1
btnlayout.setRowMinimumHeight(irow, 80)
tmpbtn = MyButton(item[1])
tmpbtn.setMyarg(item[0])
# tmpbtn.setFixedHeight(20)
tmpbtn.setSizePolicy(QSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding))
# tmpbtn.setStyleSheet("border: 1px solid rgb(255,255,255,0);background-color: rgba(255,255,255,20);font-size:16px;")
# tmpbtn.setFlat(True)
self.connect(tmpbtn, SIGNAL("myslot(PyQt_PyObject)"), self.myslot)
# self.connect(tmpbtn, SIGNAL('customContextMenuRequested(const QPoint&)'), self.on_context_menu)
tmpbtn.setAutoDefault(False)
self.btngroup.addButton(tmpbtn, int(item[0]))
btnlayout.addWidget(tmpbtn, irow, icol)
tabbtn.setIcon(QIcon("image/start.png"))
tabbtn.setStyleSheet("border: 1px solid yellow;")
tabbtn.setFixedHeight(40)
tabbtn.setFixedWidth(100)
tabbtn.setFont(QFont('宋体', 20))
# tabnums.setFixedHeight(45)
# tabnums.setFixedWidth(60)
tabnums.setFont(QFont('Courier New', 20))
tabnums.setFixedHeight(45)
tabnums.setStyleSheet("border: 2px solid blue; color:red;font-weight:light;font-size:26px;\
border-radius: 6px; \
min-width: 2em; ")
tabnums.setEditable(True)
tabnums.lineEdit().setReadOnly(True);
tabnums.lineEdit().setAlignment(Qt.AlignCenter);
model = tabnums.model()
for row in list(range(1, 7)):
item = QStandardItem(str(row))
item.setTextAlignment(Qt.AlignCenter)
item.setForeground(QColor('red'))
item.setBackground(QColor(0,200,50, 130))
model.appendRow(item)
tabnums.setCurrentIndex(2)
# tabnums.setStyleSheet ("QComboBox::drop-down {border-width: 100px;}")
# tabnums.setStyleSheet ("QComboBox::down-arrow {image: url(image/downarrow.png);top: 10px;left: 1px;}")
bottomlayout = QHBoxLayout()
bottomlayout.setSizeConstraint(QLayout.SetFixedSize)
bottomlayout.addStretch(10)
bottomlayout.addWidget(tabbtn)
bottomlayout.setSpacing(5)
bottomlayout.addWidget(tabnums)
cur.close()
return(titleLayout, btnlayout, bottomlayout)
class VoivoiShow(Slide):
'''
VoiVoi Slideshow class for displaying images from voivoi database
'''
imgList = list()
eventID = 0
mostRecent = datetime.fromtimestamp(0)
host = "127.0.0.1"
user = "******"
passwd = "secret"
db = "voivoi"
def __init__(self, parent = None):
'''
Constructor
'''
super(VoivoiShow, self).__init__(parent)
#self.setStyleSheet("background: #000;")
self.splashscreen = QImage("res/splashscreen.jpg")
#print(self.splashscreen.isNull())
if not self.splashscreen.isNull():
self.imgList.append(self.splashscreen)
self.imageLabel = QLabel()
self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.imageLabel.setParent(self)
self.httpPool = urllib3.PoolManager()
self.slideIterator = 0
self.timer.timeout.connect(self.nextImage)
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.updateImages)
self.mostRecent = datetime.fromtimestamp(0)
self.layout = QHBoxLayout()
self.layout.setMargin(0)
self.layout.addWidget(self.imageLabel)
self.layout.setAlignment(self.imageLabel, Qt.AlignHCenter)
self.setLayout(self.layout)
self.voivoifont = QFont("Helvetica", 48)
self.voivoifont.setBold(True)
def setup(self, host, user, passwd, event_id, database="voivoi", slideInterval=10, updateInterval=60):
''' setup the slide for it's display routine '''
self.host = host
print(self.host)
self.user = user
self.passwd = passwd
self.interval = slideInterval
self.updateInterval = updateInterval
self.db=database
self.eventID = event_id
self.updateImages()
def updateImages(self, buffer_limit=20):
try:
db_connection = pymysql.connect(self.host, self.user, self.passwd, self.db)
except:
print("Database connection not available")
return
sqlquery = "SELECT `categoryOrder`, `userID`, `dayID`, `comment`, `timestamp`, `eventID` FROM `pictures` WHERE `eventID`>=" + str(self.eventID) + " AND `timestamp`>'" + str(self.mostRecent) + "' ORDER BY `timestamp` ASC"
#print(sqlquery)
try:
with db_connection.cursor() as cursor:
cursor.execute(sqlquery)
result = cursor.fetchall()
for entry in result:
print(entry[4])
#print(self.mostRecent)
if entry[4] > self.mostRecent:
if entry[0] == 0:
print("BREAKING")
continue
self.mostRecent = entry[4]
image_url = "http://voivoi.eventfive.de/events/" + str(entry[5]) + "/uploads/" + str(entry[0]) + "_" + str(entry[1]) + "_" + str(entry[2]) + ".jpg"
req = self.httpPool.request('GET',image_url)
if req.status == 200:
data = req.data
print("Newer file downloaded")
might_be_image = QImage()
if might_be_image.loadFromData(data) :
#print("URL is valid")
self.drawOverlay(might_be_image, entry)
if len(self.imgList) > buffer_limit-1: #TODO: change behaviour to iteration over fixed list, to prevent jumps
self.imgList.pop(1)
self.imgList.append(might_be_image)
finally:
print("Update done, closing connection")
db_connection.close()
def drawOverlay(self, image, entry):
#establish painter
painter = QPainter()
#set adjustment factor
corner_fac = 0.037
category_fac = 0.27
text_fac = 0.03
#load images
category = QImage("res/" + str(entry[0]) + ".png")
upperLeft = QImage("res/upperLeft.png")
upperRight = QImage("res/upperRight.png")
lowerLeft = QImage("res/lowerLeft.png")
lowerRight = QImage("res/lowerRight.png")
#adjust overlays to image size
category = category.scaledToHeight(category_fac*image.height(), Qt.SmoothTransformation)
upperLeft = upperLeft.scaledToHeight(corner_fac*image.height(), Qt.SmoothTransformation)
upperRight = upperRight.scaledToHeight(corner_fac*image.height(), Qt.SmoothTransformation)
lowerLeft = lowerLeft.scaledToHeight(corner_fac*image.height(), Qt.SmoothTransformation)
lowerRight = lowerRight.scaledToHeight(corner_fac*image.height(), Qt.SmoothTransformation)
self.voivoifont.setPixelSize(text_fac*image.height())
# create size calculator for font
size_calculator = QFontMetrics(self.voivoifont)
text_width = size_calculator.boundingRect(entry[3]).width()
text_height = size_calculator.height()
#define text-boundary
margin_hor = 0.01*image.width()
max_text_bound = QRect(margin_hor,image.height()-image.height()/3, image.width()-image.width()/3, image.height()/3)
#format text for display
#text_elided = size_calculator.elidedText(entry[3].upper(), Qt.ElideRight, max_text_bound.width(), Qt.TextWordWrap)
text_upper = entry[3].upper()
text_bounds = size_calculator.boundingRect(max_text_bound, Qt.TextWordWrap, text_upper)
text_width = text_bounds.width()
text_height = text_bounds.height()
#calculate positions
margin_ver = 0.018*image.height()
#margin_hor = 0.01*image.width()
lower_bound = image.height()-margin_ver
upper_bound = lower_bound-lowerRight.height()-text_height-upperLeft.height()
#begin painting on image
painter.begin(image)
#first paint category
painter.drawImage(image.width()-category.width()-margin_hor, margin_ver, category)
# now background rectangle and corners + comment
if len(text_upper) > 0:
painter.fillRect(margin_hor, upper_bound , lowerLeft.width()+text_width+lowerRight.width(), lowerLeft.height()+text_height+upperLeft.height(), QColor(qRgb(255,255,255)))
painter.drawImage(margin_hor, lower_bound-lowerLeft.height(), lowerLeft)
painter.drawImage(margin_hor, upper_bound, upperLeft)
painter.drawImage(margin_hor+lowerLeft.width()+text_width, upper_bound, upperRight)
painter.drawImage(margin_hor+lowerLeft.width()+text_width,lower_bound-lowerRight.height(), lowerRight)
# write text to prepared rectangle
painter.setPen(QColor(qRgb(17,195,159)))
painter.setFont(self.voivoifont)
#print(text_upper)
painter.drawText(margin_hor+lowerLeft.width(),image.height()-lowerRight.height()-margin_ver-text_height, text_width, text_height, Qt.TextWordWrap, text_upper)
painter.end()
def run(self):
''' run the widgets display routine '''
self.timer.start(self.interval*1000)
self.updateTimer.start(self.updateInterval*1000)
self.nextImage()
def nextImage(self):
''' take image from list and scale it
to height of parent widget
(which should be QMainWindow).
Then generate a pixmap from the scaled
image and display it on a QLabel'''
if len(self.imgList) > 0:
image = self.imgList[self.slideIterator%len(self.imgList)]
else:
return
#print("IMAGE SIZE AFTER: " + str(image.size()))
currImage = QPixmap.fromImage(image.scaledToHeight(self.parentWidget().height(), Qt.SmoothTransformation))
self.imageLabel.setPixmap(currImage)
self.slideIterator += 1
def stop(self):
Slide.stop(self)
self.timer.stop()
def shutdown(self):
qWarning("Shutting down Slideshow-Module, this will purge all loaded images! \nTo pause, use stop() instead")
Slide.shutdown(self)
self.timer.stop()
self.imgList.clear()
def __init__(self, cheminVideo=[], taille=(250,225),
choixWidget=(RATIO, REVENIR, PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR,LIST),
debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR,
cheminParcourir=None, parent=None):
"""widget mplayer"""
QDialog.__init__(self, parent)
#=== Paramètres généraux ===#
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_(u"Player vidéo"))
#On réduit la marge pour gagner de l'espace
self.setContentsMargins(0,0,0,0)
self.systeme = os.name
### Quand EKD windows est installé, le chemin des dépendances sont ###########
### positionnées dans les variables d'environnement donc pas besoin de #######
### collecter le chemin des ces dépendances ##################################
self.cheminMPlayer = "mplayer"
##############################################################################
# liste de chemins vidéos
if type(cheminVideo) != list :
self.listeVideos=[cheminVideo]
else :
self.listeVideos = cheminVideo
# est-ce que la vidéo est lue?
self.estLue=False
# est-ce que la vidéo est en pause?
self.estEnPause=False
self.debutFin = debutFin
# Nom du fichier courant (le self n'est pas encore utile)
txtParDefaut = u"Pas de fichier lu"
if self.listeVideos.__len__()!=0:
self.fichierCourant = [txtParDefaut, self.listeVideos[0]]
else: self.fichierCourant = [txtParDefaut, ""]
# Barre des tâches de la fenêtre
self.barreTaches = barreTaches
# Taille de la vidéo
self.tailleLargeur=taille[0]
self.tailleHauteur=taille[1]
# paramètres des boutons-icones
iconTaille=22
flat=1
# Pour récupérer le temps courant depuis certains cadre
self.temps = 0
self.dureeTimer = 10 # temps en ms
###############################################################################################################################
#Pour être plus précis lors de la lecture, on prend comme unité la miliseconde. ######################
## Il faut donc utiliser une echelle 1000 fois plus grande pour les unités du slider
self.echelle=1000
###############################################################################################################################
# Permet de récupérer la durée de la vidéo depuis une instance de la classe
# Sert dans certains cadres
self.dureeVideo = 0
# Chemin sur lequel peut s'ouvrir la boite de dialogue de fichier
# associée au bouton parcourir
self.cheminPourBoutonParcourir = cheminParcourir
self.taille = taille
debug("self.taille avant lecture : %s %s" % (self.taille, type(self.taille)))
#=== Widgets ===#
self.icone_lire=QIcon("Icones" + os.sep + "player_play.png")
self.icone_pause=QIcon("Icones" + os.sep + "player_pause.png")
self.icone_arret=QIcon("Icones" + os.sep + "player_stop.png")
if Mplayer.REVENIR in choixWidget:
self.bout_revenir = QPushButton(u"Revenir")
self.bout_revenir.setIcon(QIcon("Icones" + os.sep + "revenir.png"))
if Mplayer.PARCOURIR in choixWidget:
self.bout_ouvVideo = QPushButton(u"Parcourir...")
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
self.bout_prec = QPushButton(QIcon("Icones" + os.sep + "player_rew.png"),"")
self.bout_prec.setIconSize(QSize(iconTaille, iconTaille))
self.bout_prec.setFlat(flat)
self.bout_suivant = QPushButton(QIcon("Icones" + os.sep + "player_fwd.png"),"")
self.bout_suivant.setIconSize(QSize(iconTaille, iconTaille))
self.bout_suivant.setFlat(flat)
self.LISTW=False
if Mplayer.LIST in choixWidget :
self.LISTW = True
self.listFichiers = QComboBox()
self.listFichiers.hide()
self.setListeVideo()
self.bout_LectPause = QPushButton(self.icone_lire,"")
self.bout_LectPause.setIconSize(QSize(iconTaille, iconTaille))
self.bout_LectPause.setFlat(flat)
self.bout_Arret = QPushButton(self.icone_arret,"")
self.bout_Arret.setIconSize(QSize(iconTaille, iconTaille))
self.bout_Arret.setFlat(flat)
# widget qui contiendra la vidéo
self.cibleVideo = DisplayVid(self)
# par défaut le widget-cible est noir
color = QColor(0, 0, 0)
self.cibleVideo.setAutoFillBackground(True)
self.cibleVideo.setPalette(QPalette(color))
self.cibleVideo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.cibleVideo.setFixedHeight(self.taille[1])
self.cibleVideo.setToolTip(self.fichierCourant[0])
#Choix de l'aspect ratio de la vidéo
if Mplayer.RATIO in choixWidget :
self.conf = QGroupBox()
self.conf.setContentsMargins(0,0,0,0)
self.conf.setMinimumSize(QSize(self.tailleLargeur, 0))
self.conf.setObjectName("conf")
self.verticalLayout = QHBoxLayout(self.conf)
self.verticalLayout.setObjectName("verticalLayout")
self.choicenorm = QRadioButton(self.conf)
self.choicenorm.setObjectName("choicenorm")
self.verticalLayout.addWidget(self.choicenorm)
self.choicewide = QRadioButton(self.conf)
self.choicewide.setObjectName("choicewide")
self.verticalLayout.addWidget(self.choicewide)
self.choiceone = QRadioButton(self.conf)
self.choiceone.setObjectName("choiceone")
self.verticalLayout.addWidget(self.choiceone)
self.choicenorm.setText("4:3")
self.choicewide.setText("16:9")
self.choiceone.setText("w:h")
# Checked le ratio de la vidéo
if self.listeVideos.__len__()!=0:
self.changeRatio(self.listeVideos[0])
else :
self.setRatio(4.0/3.0)
if Mplayer.RATIO in choixWidget :
self.choicenorm.setChecked(True)
self.slider = QSlider(Qt.Horizontal)
self.slider.setEnabled(True)
self.mplayerProcess = QProcess(self)
self.timer = QTimer(self)
self.tempsChrono = TracerChrono()
#=== mise-en-page/plan ===#
mhbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(self.cibleVideo)
if Mplayer.RATIO in choixWidget :
vbox.addWidget(self.conf)
hbox = QHBoxLayout()
if Mplayer.REVENIR in choixWidget:
hbox.addWidget(self.bout_revenir)
if Mplayer.PARCOURIR in choixWidget:
hbox.addWidget(self.bout_ouvVideo)
hbox.addWidget(self.bout_LectPause)
hbox.addWidget(self.bout_Arret)
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
hbox.addWidget(self.bout_prec)
hbox.addWidget(self.bout_suivant)
hbox.addWidget(self.tempsChrono)
if Mplayer.CURSEUR_A_PART not in choixWidget:
hbox.addWidget(self.slider)
vbox.addLayout(hbox)
if Mplayer.CURSEUR_A_PART in choixWidget:
hbox.setAlignment(Qt.AlignLeft)
hbox = QHBoxLayout()
hbox.addWidget(self.slider)
vbox.addLayout(hbox)
# Liste fichier dans combobox
if self.LISTW :
hbox = QHBoxLayout()
hbox.addWidget(self.listFichiers)
vbox.addLayout(hbox)
mhbox.addLayout(vbox)
self.setLayout(mhbox)
#=== connexion des widgets à des fonctions ===#
if Mplayer.REVENIR in choixWidget:
self.connect(self.bout_revenir, SIGNAL('clicked()'), SLOT('close()'))
if Mplayer.PARCOURIR in choixWidget:
self.connect(self.bout_ouvVideo, SIGNAL('clicked()'), self.ouvrirVideo)
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
self.connect(self.bout_prec, SIGNAL('clicked()'), self.precedent)
self.connect(self.bout_suivant, SIGNAL('clicked()'), self.suivant)
#Ajouté le 08/11/2009 - Liste des fichiers dans une combobox
if self.LISTW :
self.connect(self.listFichiers, SIGNAL('currentIndexChanged(int)'), self.changeVideo)
self.connect(self.bout_LectPause, SIGNAL('clicked()'), self.lectPause)
self.connect(self.bout_Arret, SIGNAL('clicked()'), self.arretMPlayer)
self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortie)
self.connect(self.mplayerProcess, SIGNAL('finished(int,QProcess::ExitStatus)'), self.finVideo)
self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel)
self.connect(self.slider, SIGNAL('sliderMoved(int)'), self.changerTempsCurseur)
self.connect(self.cibleVideo, SIGNAL('changeSize'), self.sizeMplayer)
if Mplayer.RATIO in choixWidget :
self.connect(self.choicenorm, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choicewide, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choiceone, SIGNAL("clicked(bool)"), self.defRatio)
class CustomCodeFrame(QFrame):
poke_code = pyqtSignal(str, int,
QByteArray) # code_set_label, code_id, new_bytes
log = pyqtSignal(str, str) # msg, color
def __init__(self, code_set, parent=None):
super(CustomCodeFrame, self).__init__(parent)
self.cs = code_set
self.tmr_reset_bg_clr = QTimer(self)
self.tmr_reset_bg_clr.setInterval(500) # ms
self.tmr_reset_bg_clr.timeout.connect(self.resetBGColor)
self.txt_label = QLineEdit(self)
self.txt_label.setMaximumWidth(160)
self.txt_label.setPlaceholderText('Label')
self.txt_codes = QPlainTextEdit(self)
self.txt_codes.setMaximumHeight(66)
font = QFont('Monospace')
font.setStyleHint(QFont.TypeWriter)
self.txt_codes.setFont(font)
self.txt_codes.cursorPositionChanged.connect(self.resetBGColor)
icon_height = self.txt_label.height() * 8 / 15
self.btn_poke = QPushButton(self)
self.btn_poke.setIcon(QIcon('img/flaticon/draw39.png'))
self.btn_poke.setIconSize(QSize(icon_height, icon_height))
self.btn_poke.setFixedSize(QSize(icon_height * 1.5, icon_height * 1.5))
self.btn_poke.setAutoFillBackground(True)
self.btn_poke.setStyleSheet('background-color: white')
self.btn_poke.setToolTip('Poke memory')
self.btn_poke.clicked.connect(self.onPoke)
self.layout = QHBoxLayout(self)
self.layout.addWidget(self.txt_label)
self.layout.setAlignment(self.txt_label, Qt.AlignTop)
self.layout.addWidget(self.txt_codes)
self.layout.setAlignment(self.txt_codes, Qt.AlignTop)
self.layout.addWidget(self.btn_poke)
self.layout.setAlignment(self.btn_poke, Qt.AlignTop)
self.layout.setContentsMargins(0, 2, 0, 2)
def setAlternateBGColor(self):
self.setStyleSheet(
'CustomCodeFrame { background-color:rgb(248,248,248) }')
def setErrorBGColor(self):
self.txt_codes.setStyleSheet('background-color: rgb(255,128,128)')
self.tmr_reset_bg_clr.start()
def resetBGColor(self):
if self.tmr_reset_bg_clr.isActive():
self.tmr_reset_bg_clr.stop()
self.txt_codes.setStyleSheet('background-color: white')
@pyqtSlot()
def onPoke(self):
try:
parse_custom_codes(self.cs, str(self.txt_codes.toPlainText()))
except SyntaxError, e:
self.log.emit(str(e), 'red')
self.setErrorBGColor()
return
if len(self.cs.c) <= 0:
self.log.emit('POKE failed: no codes found', 'red')
self.setErrorBGColor()
return
# Sequentially poke codes
for code in self.cs.c:
raw_bytes = struct.pack('>Q', code.dft_value)[-code.num_bytes:]
self.poke_code.emit(code.label, code.id, QByteArray(raw_bytes))
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 genTwoTab(self, tabtitle=""):
# Create the tab title sytle.
tabtitle = QLabel()
tabtitle.setFont(QFont('Courier New', 20))
tabtitle.setText("班级学生信息管理")
tabtitle.setStyleSheet("border: 1px solid blue; color:rgba(0,0,255, 220);\
background-color:rgba(201,201,201,60);\
border-radius: 6px; \
padding: 1px 18px 1px 20px;\
min-width: 8em;")
tabtitle.setMinimumHeight(50);
titleLayout = QHBoxLayout()
titleLayout.addWidget(tabtitle)
titleLayout.setAlignment(tabtitle, Qt.AlignCenter)
# Create the classnameView
self.ClassnameView = QTableView()
self.ClassnameModel = QSqlTableModel(self.ClassnameView)
self.ClassnameModel.setTable("classtable")
# self.ClassnameModel.setRelation(2, QSqlRelation("mentalmodel", "id", "name"));
self.ClassnameModel.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.ClassnameModel.select()
self.ClassnameModel.setHeaderData(0, Qt.Horizontal, "班级名称")
# for indx, iheader in enumerate(["classid", "classname"]):
# self.ClassnameModel.setHeaderData(indx+1, Qt.Horizontal, iheader)
self.ClassnameView.setModel(self.ClassnameModel)
# self.ClassnameView.setColumnHidden(0, True)
# self.ClassnameView.show()
self.ClassnameView.verticalHeader().setFixedWidth(30)
self.ClassnameView.verticalHeader().setStyleSheet("color: red;font-size:20px; ");
self.ClassnameView.setStyleSheet("QTableView{background-color: rgb(250, 250, 200, 0);"
"alternate-background-color: rgb(141, 163, 0);}"
"QTableView::item:hover {background-color: rgba(100,200,220,100);} ")
self.ClassnameView.setStyleSheet("font-size:16px; ");
self.ClassnameView.setSelectionMode(QAbstractItemView.SingleSelection)
# self.ClassnameView.dataChanged.connect(self.dataChanged)
# self.ClassnameView.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# the second list
self.StudentView = QTableView()
self.StudentModel = QSqlTableModel(self.StudentView)
self.StudentModel.setTable("student")
# self.StudentModel.setRelation(2, QSqlRelation("mentalmodel", "id", "name"));
self.StudentModel.setEditStrategy(QSqlTableModel.OnManualSubmit)
# self.StudentModel.select()
query = QSqlQuery(self.db)
strwhere = " 1=1 "
if self.g_curClassName == "":
ret = query.exec_("select classname from classtable")
query.next()
firstClassName = query.value(0)
strwhere += " and classname like '" + firstClassName + "'"
self.StudentModel.setFilter(strwhere)
self.StudentModel.select()
for indx, iheader in enumerate(["班级名称", "学生编号", "学生姓名", "答对次数", "答错次数"]):
self.StudentModel.setHeaderData(indx+1, Qt.Horizontal, iheader)
self.StudentView.setModel(self.StudentModel)
self.StudentView.setColumnHidden(0, True)
# query = QSqlQuery(self.db)
lstClassName = []
query.exec_("select classname from classtable" )
while(query.next()):
lstClassName.append(query.value(0))
self.StudentView.setItemDelegateForColumn(1, ComboBoxDelegate(self, lstClassName, self.db))
# self.StudentView.show()
self.StudentView.verticalHeader().setFixedWidth(30)
self.StudentView.verticalHeader().setStyleSheet("color: red;font-size:20px; background-color: rgb(250, 250, 200, 100)");
self.StudentView.setStyleSheet("QTableView{background-color: rgb(250, 250, 200, 0);"
"alternate-background-color: rgb(141, 163, 250);}"
"QTableView::item:hover {background-color: rgba(10,200,100,200);} "
)
self.StudentView.setStyleSheet("font-size:16px;")
self.StudentView.setSelectionMode(QAbstractItemView.SingleSelection)
self.StudentView.doubleClicked.connect(self.dbclick2)
btn_lst1_layout = QGridLayout()
newusrbtn = QPushButton("新增")
savebtn = QPushButton("保存")
revertbtn = QPushButton("撤销")
removebtn = QPushButton("删除")
btn_lst1_layout.addWidget(newusrbtn, 0, 0)
btn_lst1_layout.addWidget(savebtn, 0, 1)
btn_lst1_layout.addWidget(revertbtn, 1, 0)
btn_lst1_layout.addWidget(removebtn, 1, 1)
newusrbtn.clicked.connect(self.newClass)
savebtn.clicked.connect(self.saveClass)
revertbtn.clicked.connect(self.revertClass)
removebtn.clicked.connect(self.removeClass)
self.ClassnameView.doubleClicked.connect(self.dbclick)
btnbox2 = QDialogButtonBox(Qt.Horizontal)
newusrbtn2 = QPushButton("新增")
savebtn2 = QPushButton("保存")
revertbtn2 = QPushButton("撤销")
removebtn2 = QPushButton("删除")
btnbox2.addButton(newusrbtn2, QDialogButtonBox.ActionRole);
btnbox2.addButton(savebtn2, QDialogButtonBox.ActionRole);
btnbox2.addButton(revertbtn2, QDialogButtonBox.ActionRole);
btnbox2.addButton(removebtn2, QDialogButtonBox.ActionRole);
newusrbtn2.clicked.connect(self.newStudent)
savebtn2.clicked.connect(self.saveStudent)
revertbtn2.clicked.connect(self.revertStudent)
removebtn2.clicked.connect(self.removeStudent)
# left list layout
lst_layout_1 = QVBoxLayout()
lst_layout_1.addWidget(self.ClassnameView)
lst_layout_1.addLayout(btn_lst1_layout)
lst_layout_2 = QVBoxLayout()
lst_layout_2.addWidget(self.StudentView)
lst_layout_2.addWidget(btnbox2)
lstlayout = QHBoxLayout()
lstlayout.setMargin(5)
# lstlayout.addLayout(findbox)
lstlayout.addLayout(lst_layout_1, 2)
lstlayout.setMargin(5)
lstlayout.addLayout(lst_layout_2, 5)
labelClass = QLabel("")
labelClass.setStyleSheet("background-color:rgba(255, 255, 255,0); color:rgba(0,0,0,0);")
labelClass.setFixedHeight(40)
# labelClass.setFixedWidth(100)
# labelClass.setFont(QFont('宋体', 10))
bottomlayout = QHBoxLayout()
bottomlayout.addWidget(labelClass)
tab2layout = QVBoxLayout()
tab2layout.addLayout(titleLayout)
tab2layout.addLayout(lstlayout)
tab2layout.addLayout(bottomlayout)
self.w2.setLayout(tab2layout)
self.w2.setStyleSheet("background-color: QLinearGradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #ffffff, stop: 1 #228888);")
class OptionsLayout(QTabWidget):
''' Manages right panel.
Provides general informations, navigation and timestamp selection.
Navigation allow user to zoom in timeline.
Timestamp selection allow user to select which timestamp to display with
which color.
'''
def __init__(self, parent):
QTabWidget.__init__(self)
self.setTabPosition(QTabWidget.East)
self.init(parent)
self.initShape()
def init(self, parent):
self.VFS = libvfs.VFS.Get()
self.timeline = parent
self.swapIndex = -1
self.swapColor = ''
self.metricIndex = -1
self.configuration = []
self.zoom = False
self.exportedNode = None
def initShape(self):
self.h = QHBoxLayout()
self.vbox = QVBoxLayout()
self.vbox.setMargin(0)
self.vbox.setSpacing(0)
self.vbox.setAlignment(Qt.AlignTop)
self.setLayout(self.vbox)
self.infoBox = QGroupBox('Global information')
# self.infoBox.setFlat(True)
self.totalNodes = QLabel('No time found in nodes')
self.startTime = QLabel('No start time')
self.endTime = QLabel('No end time')
self.navBox = QGroupBox('Navigation')
self.selStartTime = QLabel('No selection start time')
self.selEndTime = QLabel('No selection end time')
self.buttonLayout = QHBoxLayout()
self.zoomButton = QPushButton('Zoom')
self.zoomButton.setEnabled(False)
self.zoomButton.connect(self.zoomButton, SIGNAL("clicked(bool)"),
self.zoomClick)
self.dezoomButton = QPushButton('Original Size')
self.dezoomButton.setEnabled(False)
self.dezoomButton.connect(self.dezoomButton, SIGNAL("clicked(bool)"),
self.dezoomClick)
self.exportButton = QPushButton('Export')
self.exportButton.setEnabled(False)
self.exportButton.connect(self.exportButton, SIGNAL("clicked(bool)"),
self.exportClick)
self.buttonLayout.setAlignment(Qt.AlignLeft)
self.buttonLayout.addWidget(self.zoomButton)
self.buttonLayout.addWidget(self.dezoomButton)
self.selectedNodes = QLabel('Nothing selected')
self.infoLayout = QVBoxLayout()
self.infoLayout.setAlignment(Qt.AlignTop)
self.infoLayout.addWidget(self.totalNodes)
self.infoLayout.addWidget(self.startTime)
self.infoLayout.addWidget(self.endTime)
self.infoBox.setLayout(self.infoLayout)
self.navLayout = QVBoxLayout()
self.navLayout.setAlignment(Qt.AlignTop)
self.navLayout.addWidget(self.selStartTime)
self.navLayout.addWidget(self.selEndTime)
self.navLayout.addLayout(self.buttonLayout)
self.navLayout.addWidget(self.selectedNodes)
self.navLayout.addWidget(self.exportButton)
self.navBox.setLayout(self.navLayout)
self.familyLayout = QVBoxLayout()
self.familyLayout.setMargin(0)
self.familyLayout.setSpacing(0)
self.familyWidget = QWidget()
self.familyWidget.setLayout(self.familyLayout)
self.familyScroll = QScrollArea()
self.insertTab(0, self.infoBox, 'Global')
self.insertTab(1, self.navBox, 'Navigation')
self.insertTab(2, self.familyScroll, 'Display')
def newInformations(self):
if self.timeline.timesCount > 1:
sTimes = str(self.timeline.timesCount) + ' time values'
else:
sTimes = 'One time value'
if self.timeline.nodeCount > 1:
sNodes = str(self.timeline.nodeCount) + ' nodes'
else:
sNodes = 'one node'
self.totalNodes.setText(sTimes + '\n' + sNodes)
if self.timeline.baseDateMin != self.timeline.dateMin:
self.startTime.setText('From ' + str(
self.timeline.fromUSec(self.timeline.baseDateMin).strftime(
'%d.%m.%Y %H:%M:%S')))
if self.timeline.selDateMin:
self.selStartTime.setText('From ' + str(
self.timeline.fromUSec(self.timeline.selDateMin).strftime(
'%d.%m.%Y %H:%M:%S')))
else:
self.selStartTime.setText('No selection start time')
if self.timeline.baseDateMax != self.timeline.dateMax:
self.endTime.setText('To ' + str(
self.timeline.fromUSec(self.timeline.baseDateMax).strftime(
'%d.%m.%Y %H:%M:%S')))
if self.timeline.selDateMax:
self.selEndTime.setText('To ' + str(
self.timeline.fromUSec(self.timeline.selDateMax).strftime(
'%d.%m.%Y %H:%M:%S')))
else:
self.selEndTime.setText('No selection end time')
def dumpOptionsConf(self):
for family in self.configuration:
if not family[1]:
print family[0] + ': empty'
else:
print family[0] + ':'
for time in family[1]:
print '\t' + time[0] + ':'
for param in time[1]:
print '\t\t' + param[0] + ':', param[1]
def createMetricTools(self):
'''
Called once countThread is over.
'''
if not self.configuration:
# First, create configuration dictionary
i = 0
for timeFamily, timeList in self.timeline.timeMap.items():
if len(timeList):
# One sub dictionary per time family
self.configuration.append([timeFamily, []])
for oneMetric in timeList:
# One sub sub dictionary per family sub time
# checked indicate if item is displayed
# color indicate which color to use
if i < len(self.timeline.colors):
self.configuration[-1][1].append([
oneMetric,
[['checked', True],
['color', self.timeline.colors[i][0]],
['checkBox', None], ['colorWidget', None],
['colorWidgetIndex', -1],
[
'orderedNodeList', {
'dates': None,
'nodes': None
}
],
[
'dateLimits',
[long(0),
long(0xffffffffffffffff)]
], ['mainPixmap', [True, None]],
['zoomPixmap', [True, None]]]
])
else:
self.configuration[-1][1].append([
oneMetric,
[['checked', False], ['color', ''],
['checkBox', None], ['colorWidget', None],
['colorWidgetIndex', -1],
[
'orderedNodeList', {
'dates': None,
'nodes': None
}
],
[
'dateLimits',
[long(0),
long(0xffffffffffffffff)]
], ['mainPixmap', [True, None]],
['zoomPixmap', [True, None]]]
])
i += 1
else:
self.configuration.append([timeFamily, []])
# Configuration object created, now create graphical view of it
# self.dumpOptionsConf()
i = 0
for family in self.configuration:
if family[1]:
box = QGroupBox(family[0])
oneTime = QVBoxLayout()
for time in family[1]:
hbox = QHBoxLayout()
time[1][2][1] = QCheckBox(':'.join(time[0]))
self.connect(time[1][2][1],
SIGNAL("stateChanged(int)"),
self.checkboxClick)
time[1][3][1] = QComboBox()
for color in self.timeline.colors:
time[1][3][1].addItem(color[0])
palette = time[1][2][1].palette()
if i < len(self.timeline.colors):
time[1][2][1].setChecked(time[1][0][1])
# Colorize foreground
palette.setColor(QPalette.WindowText,
self.timeline.colors[i][1])
time[1][3][1].setCurrentIndex(i)
time[1][4][1] = i
else:
# In case every colors are already used, don't check time (default) and don't select any color
palette.setColor(QPalette.WindowText, Qt.gray)
time[1][0][1] = False
time[1][3][1].setEnabled(False)
time[1][2][1].setPalette(palette)
self.connect(
time[1][3][1],
SIGNAL("currentIndexChanged(const QString&)"),
self.colorChange)
hbox.addWidget(time[1][2][1])
hbox.addWidget(time[1][3][1])
oneTime.addLayout(hbox)
i += 1
box.setLayout(oneTime)
optimum = box.minimumSizeHint()
box.setFixedSize(optimum)
if optimum.width() > self.familyLayout.sizeHint().width():
geom = QRect(
0, 0, optimum.width(),
self.familyLayout.sizeHint().height() +
optimum.height())
else:
geom = QRect(
0, 0,
self.familyLayout.sizeHint().width(),
self.familyLayout.sizeHint().height() +
optimum.height())
self.familyLayout.addWidget(box)
self.familyLayout.setGeometry(geom)
self.familyWidget.setFixedSize(geom.width(), geom.height())
self.familyScroll.setWidget(self.familyWidget)
else:
# Configuration object already created, we are called because am item has been
# unchecked or its color has changed.
pass
def colorChange(self, colorText):
loop = 2
while loop:
i = 0
for family in self.configuration:
for time in family[1]:
if time[1][3][1]:
if QString(time[1][1][1]) != time[1][3][1].currentText(
) and self.swapIndex == -1 and self.metricIndex == -1 and time[
1][3][1].isEnabled():
# This selection has just been changed
self.swapColor = time[1][1][1]
self.swapIndex = time[1][4][1]
time[1][1][1] = str(colorText)
#Color
palette = time[1][2][1].palette()
palette.setColor(
QPalette.WindowText, self.timeline.colors[
time[1][3][1].currentIndex()][1])
time[1][2][1].setPalette(palette)
time[1][4][1] = time[1][3][1].currentIndex()
time[1][7][1][0] = True
time[1][8][1][0] = True
self.metricIndex = i
if QString(
time[1][1][1]
) == colorText and self.swapIndex != -1 and self.metricIndex != i and time[
1][3][1].isEnabled():
# This selection is impacted because color is the same as the one just selected
# Changing color relaunch another signal.
time[1][1][1] = self.swapColor
time[1][4][1] = self.swapIndex
time[1][3][1].setCurrentIndex(self.swapIndex)
time[1][7][1][0] = True
time[1][8][1][0] = True
#Color
palette = time[1][2][1].palette()
palette.setColor(
QPalette.WindowText, self.timeline.colors[
time[1][3][1].currentIndex()][1])
time[1][2][1].setPalette(palette)
self.metricIndex = -1
i += 1
loop -= 1
# if self.swapColor == '':
# Swap already done ; redraw
self.timeline.updatePaintingArea()
self.swapIndex = -1
self.swapColor = ''
self.metricIndex = -1
def checkboxClick(self, newState):
self.selectedNodes.setText('Nothing selected')
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
for family in self.configuration:
for time in family[1]:
if time[1][2][1]:
palette = time[1][2][1].palette()
if not time[1][2][1].checkState() and time[1][0][1]:
# This box has just been unchecked
time[1][0][1] = False
time[1][3][1].setEnabled(False)
palette.setColor(QPalette.WindowText, Qt.gray)
elif time[1][2][1].checkState() and not time[1][0][1]:
# This box has just been checked
time[1][0][1] = True
time[1][3][1].setEnabled(True)
# Deactivate color already used
palette.setColor(
QPalette.WindowText, self.timeline.colors[
time[1][3][1].currentIndex()][1])
time[1][1][1] = self.timeline.colors[
time[1][3][1].currentIndex()][0]
time[1][4][1] = time[1][3][1].currentIndex()
time[1][7][1][0] = True
time[1][8][1][0] = True
for family2 in self.configuration:
# sure, 2 is ugly, it is used to search color to remove
for time2 in family2[1]:
if time2[1][3][1] and time2[1][3][1].isEnabled(
):
if self.timeline.colors[
time2[1][3][1].currentIndex(
)][0] == self.timeline.colors[
time[1][3][1].currentIndex(
)][0] and time2[1][3][
1] != time[1][3][1]:
palette2 = time2[1][2][1].palette()
time2[1][0][1] = False
time2[1][2][1].setChecked(False)
time2[1][3][1].setEnabled(False)
palette2.setColor(
QPalette.WindowText, Qt.gray)
time2[1][2][1].setPalette(palette2)
time[1][2][1].setPalette(palette)
self.timeline.updatePaintingArea()
def zoomClick(self, clickState):
self.timeline.maxOccZoom = 0
rect = self.timeline.ploter.selectionRect.rect()
newSelDateMin = self.timeline.draw.findXTime(rect.x())
newSelDateMax = self.timeline.draw.findXTime(rect.x() + rect.width())
self.timeline.selDateMin = self.timeline.toUSec(newSelDateMin)
self.timeline.selDateMax = self.timeline.toUSec(newSelDateMax)
self.newInformations()
self.dezoomButton.setEnabled(True)
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
txt = self.selectedNodes.text().__str__()
self.selectedNodes.setText(txt[:txt.rfind(' ')] + ' displayed')
self.zoom = True
self.timeline.updatePaintingArea(True)
def dezoomClick(self, clickState):
self.dezoomButton.setEnabled(False)
self.zoomButton.setEnabled(False)
self.exportButton.setEnabled(False)
self.zoom = False
self.timeline.selDateMin = None
self.timeline.selDateMax = None
self.timeline.maxOccZoom = 0
self.newInformations()
for family in self.configuration:
for time in family[1]:
if time[1][8][1]:
time[1][8][1][0] = True
time[1][8][1][1] = None
self.timeline.updatePaintingArea()
def exportClick(self, clickState):
rect = self.timeline.ploter.selectionRect.rect()
exportSelDateMin = self.timeline.draw.findXTime(rect.x())
exportSelDateMax = self.timeline.draw.findXTime(rect.x() +
rect.width())
for family in self.configuration:
for time in family[1]:
if time[1][0][1]:
nodes = []
everyNodes = self.timeline.elementsInRangeToNodeList(
time[1][5][1], self.timeline.toUSec(exportSelDateMin),
self.timeline.toUSec(exportSelDateMax))
for oneGroupNode in everyNodes:
for node in oneGroupNode:
nodes.append(node)
if len(nodes):
if not self.exportedNode:
# Create /timeline if needed
root = vfs.vfs().getnode('/Bookmarks')
baseNode = Node('timeline', 0, root)
baseNode.__disown__()
baseNode.setDir()
e = event()
e.thisown = False
e.value = RCVariant(Variant(baseNode))
self.VFS.notify(e)
# Create /timeline/<ParentName>
self.exportedNode = Node(self.timeline.node.name(),
0, baseNode)
self.exportedNode.__disown__()
self.exportedNode.setDir()
timeBaseName = self.exportedNode.absolute(
) + '/' + str(
exportSelDateMin.strftime('%d.%m.%Y %H:%M:%S')
) + ' to ' + str(
exportSelDateMax.strftime('%d.%m.%Y %H:%M:%S'))
timeBaseNode = vfs.vfs().getnode(timeBaseName)
if not timeBaseNode:
# Create /timeline/<ParentName>/dateStart to dateEnd/<Module:FullTimestampAttributePath>/
timeBaseNode = Node(
str(
exportSelDateMin.strftime(
'%d.%m.%Y %H:%M:%S')) + ' to ' + str(
exportSelDateMax.strftime(
'%d.%m.%Y %H:%M:%S')), 0,
self.exportedNode)
timeBaseNode.__disown__()
timeBaseNode.setDir()
baseFamilyName = timeBaseNode.absolute(
) + '/' + ':'.join([family[0]] + time[0])
baseFamilyNode = vfs.vfs().getnode(baseFamilyName)
if not baseFamilyNode:
# Create /timeline/<ParentName>/dateStart to dateEnd//<Module:FullTimestampAttributePath> if needed
baseFamilyNode = Node(
':'.join([family[0]] + time[0]), 0,
timeBaseNode)
baseFamilyNode.__disown__()
baseFamilyNode.setDir()
for node in nodes:
# Add each node in array as child
l = VLink(node, baseFamilyNode)
l.__disown__()
class CustomCodeFrame(QFrame):
poke_code = pyqtSignal(str, int, QByteArray) # code_set_label, code_id, new_bytes
log = pyqtSignal(str, str) # msg, color
def __init__(self, code_set, parent=None):
super(CustomCodeFrame, self).__init__(parent)
self.cs = code_set
self.tmr_reset_bg_clr = QTimer(self)
self.tmr_reset_bg_clr.setInterval(500) # ms
self.tmr_reset_bg_clr.timeout.connect(self.resetBGColor)
self.txt_label = QLineEdit(self)
self.txt_label.setMaximumWidth(160)
self.txt_label.setPlaceholderText('Label')
self.txt_codes = QPlainTextEdit(self)
self.txt_codes.setMaximumHeight(66)
font = QFont('Monospace')
font.setStyleHint(QFont.TypeWriter)
self.txt_codes.setFont(font)
self.txt_codes.cursorPositionChanged.connect(self.resetBGColor)
icon_height = self.txt_label.height()*8/15
self.btn_poke = QPushButton(self)
self.btn_poke.setIcon(QIcon('img/flaticon/draw39.png'))
self.btn_poke.setIconSize(QSize(icon_height, icon_height))
self.btn_poke.setFixedSize(QSize(icon_height*1.5, icon_height*1.5))
self.btn_poke.setAutoFillBackground(True)
self.btn_poke.setStyleSheet('background-color: white')
self.btn_poke.setToolTip('Poke memory')
self.btn_poke.clicked.connect(self.onPoke)
self.layout = QHBoxLayout(self)
self.layout.addWidget(self.txt_label)
self.layout.setAlignment(self.txt_label, Qt.AlignTop)
self.layout.addWidget(self.txt_codes)
self.layout.setAlignment(self.txt_codes, Qt.AlignTop)
self.layout.addWidget(self.btn_poke)
self.layout.setAlignment(self.btn_poke, Qt.AlignTop)
self.layout.setContentsMargins(0, 2, 0, 2)
def setAlternateBGColor(self):
self.setStyleSheet('CustomCodeFrame { background-color:rgb(248,248,248) }')
def setErrorBGColor(self):
self.txt_codes.setStyleSheet('background-color: rgb(255,128,128)')
self.tmr_reset_bg_clr.start()
def resetBGColor(self):
if self.tmr_reset_bg_clr.isActive():
self.tmr_reset_bg_clr.stop()
self.txt_codes.setStyleSheet('background-color: white')
@pyqtSlot()
def onPoke(self):
try:
parse_custom_codes(self.cs, str(self.txt_codes.toPlainText()))
except SyntaxError, e:
self.log.emit(str(e), 'red')
self.setErrorBGColor()
return
if len(self.cs.c) <= 0:
self.log.emit('POKE failed: no codes found', 'red')
self.setErrorBGColor()
return
# Sequentially poke codes
for code in self.cs.c:
raw_bytes = struct.pack('>Q', code.dft_value)[-code.num_bytes:]
self.poke_code.emit(code.label, code.id, QByteArray(raw_bytes))
def _getShpFieldsCombobox(self, qgisfield, selected_shpfield=None):
'''
Get a combobox filled with the SHP layer fields to insert in a table widget
:param qgisfield: The SHP field
:type qgisfield: QgsField
:param selected_shpfield: The QGIS field to select
:type selected_shpfield: QString, str
:returns: A combobox with the QGIS layer fields
:rtype: QWidget
'''
# Datatype mapping allowed while checking. For a given SHP type, several QGIS type may be allowed or compatible
SHP_QGIS_ALLOWED_DATATYPE_MAP = [(QVariant.String, QVariant.String),
(QVariant.LongLong,
QVariant.LongLong),
(QVariant.LongLong, QVariant.Double),
(QVariant.LongLong, QVariant.String),
(QVariant.Int, QVariant.Int),
(QVariant.Int, QVariant.LongLong),
(QVariant.Int, QVariant.Double),
(QVariant.Int, QVariant.String),
(QVariant.Double, QVariant.Double),
(QVariant.Double, QVariant.String)]
widget = QWidget()
combobox = QComboBox()
layout = QHBoxLayout(widget)
layout.addWidget(combobox, 1)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(5, 0, 5, 0)
widget.setLayout(layout)
shplayer = self.shplayer
shplayer_fields = shplayer.dataProvider().fields()
current_item_index = 0
selected_index = 0
combobox.addItem(
QCoreApplication.translate('ImportShpDialog', '<None>'), None)
current_item_index += 1
for field in shplayer_fields:
# Include only fields with compatible data type
for shp_type, qgis_type in SHP_QGIS_ALLOWED_DATATYPE_MAP:
if field.type() == shp_type and qgisfield.type() == qgis_type:
combobox.addItem(field.name(), field.name())
# Select field if same name
if field.name() == qgisfield.name(
) and selected_index == 0:
selected_index = current_item_index
if field.name() == selected_shpfield:
selected_index = current_item_index
current_item_index += 1
break
combobox.setCurrentIndex(selected_index)
combobox.currentIndexChanged.connect(
self._comboboxShpFieldIndexChanged)
return widget
def genOneTab(self, tabtitle="", tabbtn="", tabnums="", strwhere = "where studentsn like '03%' "):
# tabtitle.setFixedHeight(40)
# tabtitle.setFixedWidth(160)
tabtitle.setFont(QFont('Courier New', 20))
tabtitle.setStyleSheet("border: 3px solid blue;\
border-radius: 6px; \
padding: 1px 18px 1px 20px;\
min-width: 8em;")
model = tabtitle.model()
for row in ["随堂演板", "随堂提问"]:
item = QStandardItem(str(row))
item.setForeground(QColor('blue'))
item.setBackground(QColor(0,200,50, 130))
font = item.font()
font.setPointSize(20)
item.setFont(font)
model.appendRow(item)
tabtitle.setCurrentIndex(0)
titleLayout = QHBoxLayout()
tabtitle.setMinimumHeight(50);
titleLayout.addWidget(tabtitle)
titleLayout.setAlignment(tabtitle, Qt.AlignCenter)
btnlayout = QGridLayout()
cur = conn.cursor()
strsql = "select studentsn, studentname from student " + strwhere
cur.execute(strsql)
tmpnum = 0
for item in cur.fetchall():
irow = tmpnum // 7
icol = tmpnum % 7
tmpnum += 1
btnlayout.setRowMinimumHeight(irow, 80)
tmpbtn = QPushButton(item[1])
tmpbtn.setFont(QFont('宋体', 16))
tmpbtn.setSizePolicy(QSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding))
popMenu = QMenu(self)
entry1 = popMenu.addAction("正确")
self.connect(entry1,SIGNAL('triggered()'), lambda item=item[0]: self.answerRight(item))
entry2 = popMenu.addAction("错误")
self.connect(entry2,SIGNAL('triggered()'), lambda item=item[0]: self.answerWrong(item))
entry3 = popMenu.addAction("替换")
self.connect(entry3,SIGNAL('triggered()'), lambda item=item[0]: self.resetStudent(item))
tmpbtn.setMenu(popMenu)
tmpbtn.setAutoDefault(False)
self.btngroup.addButton(tmpbtn, int(item[0]))
btnlayout.addWidget(tmpbtn, irow, icol)
tabbtn.setIcon(QIcon("image/start.png"))
tabbtn.setStyleSheet("border: 5px solid yellow;")
tabbtn.setFixedHeight(45)
tabbtn.setFixedWidth(100)
tabbtn.setFont(QFont('宋体', 20))
# tabnums.setFixedHeight(40)
# tabnums.setFixedWidth(60)
tabnums.setFont(QFont('Courier New', 20))
tabnums.setStyleSheet("border: 5px solid blue; color:red;font-weight:bold;font-size:26px;\
border-radius: 6px; \
padding: 1px 1px 1px 1px;\
min-width: 2em; ")
# tabnums.VerticalContentAlignment="Center"
# tabnums.addItems(["1", "2", "3", "4", "5", "6"])
model = tabnums.model()
for row in list(range(1, 7)):
item = QStandardItem(str(row))
# item.setStyleSheet("background-color:rgb(0,0,255)")
item.setForeground(QColor('red'))
item.setBackground(QColor(0,200,50, 130))
# font = item.font()
# font.setPointSize(16)
# item.setFont(font)
model.appendRow(item)
tabnums.setCurrentIndex(2)
bottomlayout = QHBoxLayout()
bottomlayout.setSizeConstraint(QLayout.SetFixedSize)
bottomlayout.addStretch(10)
bottomlayout.addWidget(tabbtn)
bottomlayout.setSpacing(5)
bottomlayout.addWidget(tabnums)
cur.close()
return(titleLayout, btnlayout, bottomlayout)
class divergenceMeterWidget(QWidget):
def __init__(self, parent):
super(divergenceMeterWidget, self).__init__()
self.parent = parent
self.l_size = QSize(104, 307)
self.setUpdatesEnabled(True)
#Create labels
self.tube_1 = QLabel()
self.tube_2 = QLabel()
self.tube_3 = QLabel()
self.tube_4 = QLabel()
self.tube_5 = QLabel()
self.tube_6 = QLabel()
self.tube_7 = QLabel()
self.tube_8 = QLabel()
#Create horizontal layyout
self.h_layout = QHBoxLayout(self)
self.h_layout.setAlignment(Qt.AlignHCenter)
self.h_layout.setSpacing(0)
self.h_layout.setContentsMargins(0, 0, 0, 0)
#Add labels to horizontal layout
self.h_layout.addWidget(self.tube_1)
self.h_layout.addWidget(self.tube_2)
self.h_layout.addWidget(self.tube_3)
self.h_layout.addWidget(self.tube_4)
self.h_layout.addWidget(self.tube_5)
self.h_layout.addWidget(self.tube_6)
self.h_layout.addWidget(self.tube_7)
self.h_layout.addWidget(self.tube_8)
#Generate random line
self.generate_random_line()
self.setLayout(self.h_layout)
def generate_random_line(self):
"""This function generate a random line"""
self.tube_1.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
self.tube_3.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_4.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_6.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_7.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.repaint()
def generate_new_random_lines(self):
"""Generate 100 random lines"""
for i in range(100):
self.tube_1.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
self.tube_3.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_4.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_6.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_7.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[random.randint(1, 10)]).scaled(self.l_size))
self.repaint()
def generate_random_digits(self):
"""Random results"""
for i in range(100):
self.tube_1.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_3.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_4.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_6.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_7.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[random.randint(0, 10)]).scaled(self.l_size))
self.repaint()
def show_date(self):
"""Display date"""
self.generate_random_digits()
self.is_running_date = True
while self.is_running_date is True:
clock = time.localtime()
year = str(clock.tm_year)
mon = str(clock.tm_mon)
day = str(clock.tm_mday)
self.parent.setWindowTitle('Divergence Meter - %s' % time.strftime(
'%m/%d/%Y', clock))
app.processEvents()
if len(mon) == 1:
self.tube_1.setPixmap(QPixmap(IMAGES[1]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[get_digit(mon)]).scaled(self.l_size))
else:
self.tube_1.setPixmap(QPixmap(IMAGES[get_digit(mon[0])]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[get_digit(mon[1])]).scaled(self.l_size))
self.tube_3.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
if len(day) == 1:
self.tube_4.setPixmap(QPixmap(IMAGES[1]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[get_digit(day)]).scaled(self.l_size))
else:
self.tube_4.setPixmap(QPixmap(IMAGES[get_digit(day[0])]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[get_digit(day[1])]).scaled(self.l_size))
self.tube_6.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
self.tube_7.setPixmap(QPixmap(IMAGES[get_digit(year[2])]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[get_digit(year[3])]).scaled(self.l_size))
app.processEvents()
def show_time(self):
"""Display time"""
self.generate_random_digits()
self.is_running_time = True
while self.is_running_time is True:
clock = time.localtime()
hour = str(clock.tm_hour)
mins = str(clock.tm_min)
sec = str(clock.tm_sec)
self.parent.setWindowTitle('Divergence Meter - %s' % time.strftime(
'%H:%M:%S', clock))
app.processEvents()
if len(hour) == 1:
self.tube_1.setPixmap(QPixmap(IMAGES[1]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[get_digit(hour)]).scaled(self.l_size))
else:
self.tube_1.setPixmap(QPixmap(IMAGES[get_digit(hour[0])]).scaled(self.l_size))
self.tube_2.setPixmap(QPixmap(IMAGES[get_digit(hour[1])]).scaled(self.l_size))
self.tube_3.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
if len(mins) == 1:
self.tube_4.setPixmap(QPixmap(IMAGES[1]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[get_digit(mins)]).scaled(self.l_size))
else:
self.tube_4.setPixmap(QPixmap(IMAGES[get_digit(mins[0])]).scaled(self.l_size))
self.tube_5.setPixmap(QPixmap(IMAGES[get_digit(mins[1])]).scaled(self.l_size))
self.tube_6.setPixmap(QPixmap(IMAGES[0]).scaled(self.l_size))
if len(sec) == 1:
self.tube_7.setPixmap(QPixmap(IMAGES[1]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[get_digit(sec)]).scaled(self.l_size))
else:
self.tube_7.setPixmap(QPixmap(IMAGES[get_digit(sec[0])]).scaled(self.l_size))
self.tube_8.setPixmap(QPixmap(IMAGES[get_digit(sec[1])]).scaled(self.l_size))
app.processEvents()
