def createSpinBox(self, variable_name, variable_value, variable_type, analysis_module_variables_model):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setMaximum(analysis_module_variables_model.getVariableMaximumValue(variable_name))
spinner.setMinimum(analysis_module_variables_model.getVariableMinimumValue(variable_name))
spinner.setSingleStep(analysis_module_variables_model.getVariableStepValue(variable_name))
if variable_value is not None:
spinner.setValue(variable_value)
spinner.valueChanged.connect(partial(self.valueChanged, variable_name, variable_type, spinner))
return spinner
def createSpinBox(self, variable_name, variable_value, variable_type, analysis_module_variables_model):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setMaximum(analysis_module_variables_model.getVariableMaximumValue(variable_name))
spinner.setMinimum(analysis_module_variables_model.getVariableMinimumValue(variable_name))
spinner.setSingleStep(analysis_module_variables_model.getVariableStepValue(variable_name))
if variable_value is not None:
spinner.setValue(variable_value)
spinner.valueChanged.connect(partial(self.valueChanged, variable_name, variable_type, spinner))
return spinner
def createIntegerSpinner(self, minimum, maximum):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setRange(minimum, maximum)
spinner.setKeyboardTracking(False)
spinner.editingFinished.connect(self.plotScaleChanged)
spinner.valueChanged.connect(self.plotScaleChanged)
return spinner
def createIntegerSpinner(self, minimum, maximum):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setRange(minimum, maximum)
spinner.setKeyboardTracking(False)
spinner.editingFinished.connect(self.plotScaleChanged)
spinner.valueChanged.connect(self.plotScaleChanged)
return spinner
class ProprietesAffichage(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
self.parent = parent
self.panel = self.parent.parent.panel
self.canvas = self.panel.canvas
self.islabel = self.parent.parent.islabel
self.objets = parent.objets
self.sizer = QVBoxLayout()
self.changements = {} # ce dictionnaire contiendra tous les styles modifiés
encadre = QHBoxLayout()
if not self.islabel:
proprietes = {'fixe': u'Objet fixe', 'visible': u'Objet visible', 'trace': u'Laisser une trace'}
for propriete, titre in proprietes.items():
self.add_checkbox(encadre, propriete, titre)
encadre.addStretch()
encadre1 = QVBoxLayout()
if not self.islabel:
ligne = QHBoxLayout()
if len(self.objets) == 1:
self.etiquette = etiquette = QLineEdit()
etiquette.setText(self.objets[0].legende)
etiquette.setMinimumWidth(200)
etiquette.editingFinished.connect(self.EvtEtiquette)
ligne.addWidget(etiquette)
if [objet for objet in self.objets if objet.etiquette is not None]:
editer = QPushButton(u"Style")
editer.clicked.connect(self.EvtLabelStyle)
ligne.addWidget(editer)
encadre1.addLayout(ligne)
objets = [objet for objet in self.objets if objet.mode_affichage is not None]
if objets:
mode = objets[0].mode_affichage
legende = QHBoxLayout()
self.radios = OrderedDict((
(NOM, QRadioButton("Nom")),
(TEXTE, QRadioButton(u"Texte")),
(FORMULE, QRadioButton(u"Formule")),
(RIEN, QRadioButton(u"Aucun")),
))
if all(objet.mode_affichage == mode for objet in objets):
self.radios[mode].setChecked(True)
for mode, radio in self.radios.iteritems():
radio.toggled.connect(partial(self.EvtMode, mode))
legende.addWidget(radio)
legende.addStretch()
encadre1.addWidget(QLabel(u"Afficher : "))
encadre1.addLayout(legende)
encadre2 = QVBoxLayout()
objets = [objet for objet in self.objets if objet.style("style") is not None]
# on ne peut regler les styles simultanement que pour des objets de meme categorie
categorie = objets and objets[0].style("categorie") or None
if objets and categorie and all(objet.style("categorie") == categorie for objet in objets):
choix = QHBoxLayout()
choix.addWidget(QLabel(u"Style de l'objet : "))
#categorie = objets[0].style("categorie") or "lignes"
self.liste_styles = getattr(param, "styles_de_" + categorie, [])
self.style = QComboBox()
self.style.addItems(self.liste_styles)
self.style.currentIndexChanged.connect(self.EvtStyle)
style = objets[0].style("style")
if style in self.liste_styles and all(objet.style("style") == style for objet in objets):
self.style.setCurrentIndex(self.liste_styles.index(style)) # on sélectionne le style actuel
choix.addWidget(self.style)
choix.addStretch()
encadre2.addLayout(choix)
objets = [objet for objet in self.objets if objet.style("hachures") is not None]
if objets:
choix = QHBoxLayout()
choix.addWidget(QLabel(u"Style des hâchures : "))
self.types_de_hachures = getattr(param, "types_de_hachures", [])
self.hachures = QComboBox()
self.hachures.addItems(self.types_de_hachures)
self.hachures.currentIndexChanged.connect(self.EvtHachures)
hachures = objets[0].style("hachures")
if hachures in self.types_de_hachures and all(objet.style("hachures") == hachures for objet in objets):
self.hachures.setCurrentIndex(self.types_de_hachures.index(hachures)) # on sélectionne les hachures actuelles
choix.addWidget(self.hachures)
choix.addStretch()
encadre2.addLayout(choix)
objets = [objet for objet in self.objets if objet.style("famille") is not None]
categorie = objets and objets[0].style("categorie") or None
if objets and categorie and all(objet.style("categorie") == categorie for objet in objets):
choix = QHBoxLayout()
choix.addWidget(QLabel("Police : "))
#categorie = self.objet.style("categorie") or "lignes"
self.liste_familles = getattr(param, "familles_de_" + categorie, [])
self.famille = QComboBox()
self.famille.addItems(self.liste_familles)
self.famille.currentIndexChanged.connect(self.EvtFamille)
famille = objets[0].style("famille")
if famille in self.liste_familles and all(objet.style("famille") == famille for objet in objets):
self.famille.setCurrentIndex(self.liste_familles.index(famille)) # on sélectionne la famille actuelle
choix.addWidget(self.famille)
choix.addStretch()
encadre2.addLayout(choix)
objets = [objet for objet in self.objets if objet.style("couleur") is not None]
if objets:
couleur = objets[0].style("couleur")
choix = QHBoxLayout()
choix.addWidget(QLabel(u"Couleur de l'objet : "))
if all(objet.style("couleur") == couleur for objet in objets):
# conversion du format matplotlib au format Qt
r, g, b = colorConverter.to_rgb(couleur)
couleur = QColor(int(255*r), int(255*g), int(255*b))
else:
couleur = None
b = ColorSelecter(self, color=couleur)
b.colorSelected.connect(self.OnSelectColour)
choix.addWidget(b)
choix.addStretch()
encadre2.addLayout(choix)
objets = [objet for objet in self.objets if objet.style("epaisseur") is not None]
if objets:
epaiss = objets[0].style("epaisseur")
epaisseur = QHBoxLayout()
epaisseur.addWidget(QLabel(u"Epaisseur (en 10e de pixels) : "))
self.epaisseur = QSpinBox()
self.epaisseur.setMinimumWidth(30)
self.epaisseur.setRange(1, 10000)
if all(objet.style("epaisseur") == epaiss for objet in objets):
self.epaisseur.setValue(10*epaiss)
else:
self.epaisseur.setSpecialValueText(' ')
print(u'FIXME: cas non géré.')
self.epaisseur.valueChanged.connect(self.EvtEpaisseur)
epaisseur.addWidget(self.epaisseur)
epaisseur.addStretch()
encadre2.addLayout(epaisseur)
objets = [objet for objet in self.objets if objet.style("taille") is not None]
if objets:
tail = objets[0].style("taille")
taille = QHBoxLayout()
taille.addWidget(QLabel(u"Taille (en 10e de pixels) : "))
self.taille = QSpinBox()
self.taille.setMinimumWidth(30)
self.taille.setRange(1,10000)
if all(objet.style("taille") == tail for objet in objets):
self.taille.setValue(10*tail)
else:
self.taille.setSpecialValueText(' ')
print(u'FIXME: cas non géré.')
self.taille.valueChanged.connect(self.EvtTaille)
taille.addWidget(self.taille)
taille.addStretch()
encadre2.addLayout(taille)
objets = [objet for objet in self.objets if objet.style("position") is not None]
if objets:
pos = objets[0].style("position")
position = QHBoxLayout()
position.addWidget(QLabel(u"Position de la flêche : "))
self.position = QSpinBox()
self.position.setMinimumWidth(30)
self.position.setRange(0, 100)
if all(objet.style("position") == pos for objet in objets):
self.position.setValue(100*pos)
else:
self.position.setSpecialValueText(' ')
print(u'FIXME: cas non géré.')
self.position.valueChanged.connect(self.EvtPosition)
position.addWidget(self.position)
position.addStretch()
encadre2.addLayout(position)
objets = [objet for objet in self.objets if objet.style("angle") is not None]
if objets:
ang = objets[0].style("angle")
angle = QHBoxLayout()
angle.addWidget(QLabel(u"Angle (en degré) : "))
self.angle = QSpinBox()
self.angle.setMinimumWidth(30)
self.angle.setRange(-180, 180)
self.angle.setSpecialValueText('auto')
self.angle.setSuffix(u'°');
self.angle.setWrapping(True)
if all(objet.style("angle") == ang for objet in objets):
self.angle.setValue(ang if ang != 'auto' else -180)
else:
self.angle.setSpecialValueText(' ')
print(u'FIXME: cas non géré.')
self.angle.valueChanged.connect(self.EvtAngle)
angle.addWidget(self.angle)
angle.addStretch()
encadre2.addLayout(angle)
self.add_checkbox(encadre, 'double_fleche', u"Flêche double")
objets = [objet for objet in self.objets if objet.style("codage") is not None]
# on ne peut regler les codages simultanement que pour des objets de meme categorie
categorie = objets and objets[0].style("categorie") or None
if objets and categorie and all(objet.style("categorie") == categorie for objet in objets):
choix = QHBoxLayout()
choix.addWidget(QLabel("Codage : "))
#categorie = objets[0].style("categorie") or "lignes"
self.liste_codages = getattr(param, "codage_des_" + categorie, [])
self.codage = QComboBox()
self.codage.addItems(self.liste_codages)
self.codage.currentIndexChanged.connect(self.EvtCodage)
codage = objets[0].style("codage")
if codage in self.liste_codages and all(objet.style("codage") == codage for objet in objets):
self.codage.setCurrentIndex(self.liste_codages.index(codage)) # on sélectionne le codage actuel
choix.addWidget(self.codage)
encadre2.addLayout(choix)
boutons = QHBoxLayout()
ok = QPushButton('OK')
ok.clicked.connect(self.EvtOk)
boutons.addWidget(ok)
appliquer = QPushButton(u"Appliquer")
appliquer.clicked.connect(self.EvtAppliquer)
boutons.addWidget(appliquer)
if not self.islabel:
supprimer = QPushButton(u"Supprimer")
supprimer.clicked.connect(self.EvtSupprimer)
boutons.addWidget(supprimer)
annuler = QPushButton(u"Annuler")
annuler.clicked.connect(self.EvtAnnuler)
boutons.addWidget(annuler)
if encadre.count(): # ne pas afficher une rubrique vide !
encadre_box = QGroupBox(u"Mode d'affichage")
encadre_box.setLayout(encadre)
self.sizer.addWidget(encadre_box)
if encadre1.count():
encadre1_box = QGroupBox(u"Etiquette")
encadre1_box.setLayout(encadre1)
self.sizer.addWidget(encadre1_box)
if encadre2.count():
encadre2_box = QGroupBox(u"Styles")
encadre2_box.setLayout(encadre2)
self.sizer.addWidget(encadre2_box)
self.sizer.addLayout(boutons)
self.setLayout(self.sizer)
##self.parent.parent.dim1 = self.sizer.CalcMin().Get()
def add_checkbox(self, layout, propriete, titre):
objets = [objet for objet in self.objets if objet.style(propriete) is not None]
if objets:
cb = QCheckBox(titre)
cb.setTristate(True)
layout.addWidget(cb)
verifies = [objet.style(propriete) is True for objet in objets]
if not any(verifies):
etat = Qt.Unchecked
elif all(verifies):
etat = Qt.Checked
else:
etat = Qt.PartiallyChecked
cb.setCheckState(etat)
cb.stateChanged.connect(partial(self.checked, propriete=propriete))
cb.stateChanged.connect(partial(cb.setTristate, False))
def EvtMode(self, valeur):
self.changements["mode"] = valeur
def checked(self, state, propriete):
# Bug avec Qt 4.8.1 - En cochant la case la première fois, on obtient
# Qt.PartiallyChecked, et non Qt.Checked. Si ensuite, on décoche et on
# recoche, on obtient bien Qt.Checked.
self.changements[propriete] = (state != Qt.Unchecked)
def EvtEtiquette(self):
self.changements["label"] = self.etiquette.text()
def OnSelectColour(self, color):
# conversion du format Qt au format matplotlib
r, g, b, a = color.getRgb()
self.changements["couleur"] = (r/255, g/255, b/255, a/255)
def EvtStyle(self, index):
self.changements["style"] = self.liste_styles[index]
def EvtHachures(self, index):
self.changements["hachures"] = self.types_de_hachures[index]
def EvtCodage(self, index):
self.changements["codage"] = self.liste_codages[index]
def EvtFamille(self, index):
self.changements["famille"] = self.liste_familles[index]
def EvtOk(self):
self.EvtAppliquer()
self.EvtAnnuler()
def EvtAppliquer(self):
with self.canvas.geler_affichage(actualiser=True, sablier=True):
try:
for objet in self.objets:
changements = self.changements.copy()
mode = changements.pop('mode', None)
label = changements.pop('label', None)
for key in changements.copy():
if objet.style(key) is None: # le style n'a pas de sens pour l'objet
changements.pop(key)
if mode is not None or label is not None:
self.canvas.executer(u"%s.label(%s, %s)" %(objet.nom, repr(label), mode))
if mode is None:
mode = objet.etiquette.style("mode")
self.changements["mode"] = mode
self.radios[mode].setChecked(True)
if self.islabel:
self.canvas.executer(u"%s.etiquette.style(**%s)" %(objet.parent.nom, changements))
else:
self.canvas.executer(u"%s.style(**%s)" %(objet.nom, changements))
except:
print_error()
def EvtSupprimer(self):
with self.canvas.geler_affichage(actualiser=True, sablier=True):
for objet in self.objets:
self.canvas.executer(u"del %s" %objet.nom)
self.EvtAnnuler()
def EvtAnnuler(self):
# Ce qui suit corrige un genre de bug bizarre de wx:
# quand une fenêtre de sélection de couleur a été affichée,
# la fenêtre principale passe au second plan à la fermeture de la fenêtre de propriétés ?!?
# (ce qui est très désagréable dès qu'un dossier est ouvert dans l'explorateur, par exemple !)
# -> à supprimer avec Qt ?
self.parent.parent.fenetre_principale.raise_()
self.parent.parent.close() # fermeture de la frame
def EvtLabelStyle(self):
win = Proprietes(self.parent, [objet.etiquette for objet in self.objets
if objet.etiquette is not None], True)
win.show()
def EvtEpaisseur(self):
self.changements["epaisseur"] = self.epaisseur.value()/10
def EvtTaille(self):
self.changements["taille"] = self.taille.value()/10
def EvtAngle(self):
angle = self.angle.value()
self.changements["angle"] = (angle if angle != -180 else 'auto')
def EvtPosition(self):
self.changements["position"] = self.position.value()/100
class NumberBoxPanel(QWidget):
def __init__(self, parent, resoution = "0.0000"):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("NumberBoxPanel" + str(len(parent.findChildren(NumberBoxPanel))))
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(0,0,0,0)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
if resoution != None:
self.numberBox = QLineEdit(self.frameBoxPanel)
self.numberBox.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.numberBox.setFont(font)
self.numberBox.setObjectName(self.objectName() + "_numberBox")
self.numberBox.setText("0.0")
self.numberBox.setMinimumWidth(70)
self.numberBox.setMaximumWidth(70)
self.hLayoutframeBoxPanel.addWidget(self.numberBox)
self.numberBox.textChanged.connect(self.numberBoxChanged)
self.numberBox.editingFinished.connect(self.numberBoxEditingFinished)
else:
self.numberBox = QSpinBox(self.frameBoxPanel)
self.numberBox.setObjectName(self.objectName() + "_numberBox")
self.numberBox.setMinimumWidth(70)
self.numberBox.setMaximumWidth(70)
self.numberBox.setMinimum(-100000000)
self.numberBox.setMaximum(100000000)
self.numberBox.setValue(1)
self.hLayoutframeBoxPanel.addWidget(self.numberBox)
self.imageButton = QPushButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal, QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
spacerItem = QSpacerItem(10,10,QSizePolicy.Expanding, QSizePolicy.Minimum)
self.hLayoutBoxPanel.addItem(spacerItem)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.numberResolution = resoution
str0 = String.Number2String(6.6788, "0.0000")
self.Value = 0
self.captionUnits = ""
def imageButtonClicked(self):
self.emit(SIGNAL("Event_1"), self)
def method_6(self, string_0):
return "%s%s\t%f %s"%(string_0, self.Caption, self.Value, self.CaptionUnits);
def numberBoxEditingFinished(self):
self.emit(SIGNAL("editingFinished"), self)
def numberBoxChanged(self):
try:
test = float(self.numberBox.text())
self.emit(SIGNAL("Event_0"), self)
except:
if self.numberBox.text() == "" or self.numberBox.text() == "-" or self.numberBox.text() == "+":
return
str0 = "You must input the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
self.numberBox.setText("0.0")
def get_CaptionUnits(self):
return self.captionUnits
def set_CaptionUnits(self, captionUnits):
self.captionUnits = captionUnits
CaptionUnits = property(get_CaptionUnits, set_CaptionUnits, None, None)
def get_Caption(self):
caption = self.captionLabel.text()
findIndex = caption.indexOf("(")
if findIndex > 0:
val = caption.left(findIndex)
return val
return caption
def set_Caption(self, captionStr):
if self.CaptionUnits != "" and self.CaptionUnits != None:
self.captionLabel.setText(QString(captionStr + "(") + self.CaptionUnits + QString("):"))
else:
self.captionLabel.setText(captionStr + ":")
Caption = property(get_Caption, set_Caption, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
def get_Value(self):
try:
if self.numberResolution != None:
return float(self.numberBox.text())
else:
return self.numberBox.value()
except:
return 0.0
def set_Value(self, valueFloat):
if self.numberResolution != None:
if valueFloat == None or valueFloat == "":
rStr = String.Number2String(0, self.numberResolution)
self.numberBox.setText(rStr)
return
try:
test = float(valueFloat)
rStr = String.Number2String(test, self.numberResolution)
self.numberBox.setText(rStr)
except:
str0 = "You must put the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
rStr = String.Number2String(0, self.numberResolution)
self.numberBox.setText(rStr)
else:
try:
test = int(valueFloat)
self.numberBox.setValue(test)
except:
str0 = "You must put the float type in \"%s\"."%(self.Caption)
QMessageBox.warning(self, "Warning" , str0)
self.numberBox.setValue(0)
Value = property(get_Value, set_Value, None, None)
# def get_IsEmpty(self):
# return self.numberBox.text() == "" or self.numberBox.text() == None
# IsEmpty = property(get_IsEmpty, None, None, None)
def get_ReadOnly(self):
return self.numberBox.isReadOnly()
def set_ReadOnly(self, bool):
self.numberBox.setReadOnly(bool)
ReadOnly = property(get_ReadOnly, set_ReadOnly, None, None)
def set_LabelWidth(self, width):
self.captionLabel.setMinimumSize(QSize(width, 0))
self.captionLabel.setMaximumSize(QSize(width, 16777215))
LabelWidth = property(None, set_LabelWidth, None, None)
def set_Width(self, width):
self.numberBox.setMinimumSize(QSize(width, 0))
self.numberBox.setMaximumSize(QSize(width, 16777215))
Width = property(None, set_Width, None, None)
def get_Enabled(self):
return self.isEnabled()
def set_Enabled(self, bool):
self.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def set_Button(self, imageName):
if imageName == None or imageName == "":
self.imageButton.setVisible(False)
return
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/" + imageName)), QIcon.Normal, QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setVisible(True)
Button = property(None, set_Button, None, None)