class Indenting(preferences.Group):
def __init__(self, page):
super(Indenting, self).__init__(page)
layout = QGridLayout(spacing=1)
self.setLayout(layout)
self.tabwidthBox = QSpinBox(minimum=1, maximum=99)
self.tabwidthLabel = l = QLabel()
l.setBuddy(self.tabwidthBox)
self.nspacesBox = QSpinBox(minimum=0, maximum=99)
self.nspacesLabel = l = QLabel()
l.setBuddy(self.nspacesBox)
self.dspacesBox = QSpinBox(minimum=0, maximum=99)
self.dspacesLabel = l = QLabel()
l.setBuddy(self.dspacesBox)
layout.addWidget(self.tabwidthLabel, 0, 0)
layout.addWidget(self.tabwidthBox, 0, 1)
layout.addWidget(self.nspacesLabel, 1, 0)
layout.addWidget(self.nspacesBox, 1, 1)
layout.addWidget(self.dspacesLabel, 2, 0)
layout.addWidget(self.dspacesBox, 2, 1)
self.tabwidthBox.valueChanged.connect(page.changed)
self.nspacesBox.valueChanged.connect(page.changed)
self.dspacesBox.valueChanged.connect(page.changed)
self.translateUI()
def translateUI(self):
self.setTitle(_("Indenting Preferences"))
self.tabwidthLabel.setText(_("Visible Tab Width:"))
self.tabwidthBox.setToolTip(_(
"The visible width of a Tab character in the editor."))
self.nspacesLabel.setText(_("Indent text with:"))
self.nspacesBox.setToolTip(_(
"How many spaces to use for indenting one level.\n"
"Move to zero to use a Tab character for indenting."))
self.nspacesBox.setSpecialValueText(_("Tab"))
self.dspacesLabel.setText(_("Tab ouside indent inserts:"))
self.dspacesBox.setToolTip(_(
"How many spaces to insert when Tab is pressed outside the indent, "
"elsewhere in the document.\n"
"Move to zero to insert a literal Tab character in this case."))
self.nspacesBox.setSpecialValueText(_("Tab"))
self.dspacesBox.setSpecialValueText(_("Tab"))
# L10N: abbreviation for "n spaces" in spinbox, n >= 1, no plural forms
prefix, suffix = _("{num} spaces").split("{num}")
self.nspacesBox.setPrefix(prefix)
self.nspacesBox.setSuffix(suffix)
self.dspacesBox.setPrefix(prefix)
self.dspacesBox.setSuffix(suffix)
def loadSettings(self):
s = QSettings()
s.beginGroup("indent")
self.tabwidthBox.setValue(s.value("tab_width", 8, int))
self.nspacesBox.setValue(s.value("indent_spaces", 2, int))
self.dspacesBox.setValue(s.value("document_spaces", 8, int))
def saveSettings(self):
s = QSettings()
s.beginGroup("indent")
s.setValue("tab_width", self.tabwidthBox.value())
s.setValue("indent_spaces", self.nspacesBox.value())
s.setValue("document_spaces", self.dspacesBox.value())
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)
encadre1 = QVBoxLayout()
if not self.islabel:
ligne = QHBoxLayout()
if len(self.objets) == 1:
self.etiquette = etiquette = QLineEdit()
etiquette.setText(self.objets[0].style("label"))
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.style("legende") is not None]
if objets:
leg = objets[0].style("legende")
legende = QHBoxLayout()
self.radio_nom = QRadioButton("Nom")
##self.radio_nom.SetValue(0)
self.radio_etiquette = QRadioButton(u"Texte")
##self.radio_etiquette.SetValue(0)
self.radio_formule = QRadioButton(u"Formule")
##self.radio_formule.SetValue(0)
self.radio_aucun = QRadioButton(u"Aucun")
##self.radio_aucun.SetValue(0)
if all(objet.style("legende") == leg for objet in objets):
if leg == NOM:
self.radio_nom.setChecked(True)
elif leg == TEXTE:
self.radio_etiquette.setChecked(True)
elif leg == FORMULE:
self.radio_formule.setChecked(True)
elif leg == RIEN:
self.radio_aucun.setChecked(True)
self.radio_nom.toggled.connect(partial(self.EvtLegende, NOM))
self.radio_etiquette.toggled.connect(partial(self.EvtLegende, TEXTE))
self.radio_formule.toggled.connect(partial(self.EvtLegende, FORMULE))
self.radio_aucun.toggled.connect(partial(self.EvtLegende, RIEN))
legende.addWidget(self.radio_nom)
legende.addWidget(self.radio_etiquette)
legende.addWidget(self.radio_formule)
legende.addWidget(self.radio_aucun)
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)
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.hachure.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)
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)
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)
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.setMinimumSize(30, 50)
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)
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.setMinimumSize(30, 50)
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)
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.setMinimumSize(30, 50)
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)
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.setMinimumSize(30, 50)
self.angle.setRange(0, 360)
if all(objet.style("angle") == ang for objet in objets):
self.angle.setValue(ang)
else:
self.angle.setSpecialValueText(' ')
print(u'FIXME: cas non géré.')
self.angle.valueChanged.connect(self.EvtAngle)
angle.addWidget(self.angle)
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")
encadre_box.setLayout(encadre1)
self.sizer.addWidget(encadre1_box)
if encadre2.count():
encadre2_box = QGroupBox(u"Styles")
encadre_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))
cb.stateChanged.connect(partial(cb.setTristate, False))
def EvtLegende(self, valeur):
self.changements["legende"] = valeur
def checked(self, propriete, state):
self.changements[propriete] = (state == Qt.Checked)
def EvtEtiquette(self):
self.changements["label"] = self.etiquette.toPlainText()
def OnSelectColour(self, color):
# conversion du format Qt au format matplotlib
self.changements["couleur"] = color.getRgb()
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()
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 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):
self.changements["angle"] = self.angle.value()
def EvtPosition(self):
self.changements["position"] = self.position.value()/100
class Indenting(preferences.Group):
def __init__(self, page):
super(Indenting, self).__init__(page)
layout = QGridLayout(spacing=1)
self.setLayout(layout)
self.tabwidthBox = QSpinBox(minimum=1, maximum=99)
self.tabwidthLabel = l = QLabel()
l.setBuddy(self.tabwidthBox)
self.nspacesBox = QSpinBox(minimum=0, maximum=99)
self.nspacesLabel = l = QLabel()
l.setBuddy(self.nspacesBox)
self.dspacesBox = QSpinBox(minimum=0, maximum=99)
self.dspacesLabel = l = QLabel()
l.setBuddy(self.dspacesBox)
layout.addWidget(self.tabwidthLabel, 0, 0)
layout.addWidget(self.tabwidthBox, 0, 1)
layout.addWidget(self.nspacesLabel, 1, 0)
layout.addWidget(self.nspacesBox, 1, 1)
layout.addWidget(self.dspacesLabel, 2, 0)
layout.addWidget(self.dspacesBox, 2, 1)
self.tabwidthBox.valueChanged.connect(page.changed)
self.nspacesBox.valueChanged.connect(page.changed)
self.dspacesBox.valueChanged.connect(page.changed)
self.translateUI()
def translateUI(self):
self.setTitle(_("Indenting Preferences"))
self.tabwidthLabel.setText(_("Visible Tab Width:"))
self.tabwidthBox.setToolTip(_(
"The visible width of a Tab character in the editor."))
self.nspacesLabel.setText(_("Indent text with:"))
self.nspacesBox.setToolTip(_(
"How many spaces to use for indenting one level.\n"
"Move to zero to use a Tab character for indenting."))
self.nspacesBox.setSpecialValueText(_("Tab"))
self.dspacesLabel.setText(_("Tab outside indent inserts:"))
self.dspacesBox.setToolTip(_(
"How many spaces to insert when Tab is pressed outside the indent, "
"elsewhere in the document.\n"
"Move to zero to insert a literal Tab character in this case."))
self.nspacesBox.setSpecialValueText(_("Tab"))
self.dspacesBox.setSpecialValueText(_("Tab"))
# L10N: abbreviation for "n spaces" in spinbox, n >= 1, no plural forms
prefix, suffix = _("{num} spaces").split("{num}")
self.nspacesBox.setPrefix(prefix)
self.nspacesBox.setSuffix(suffix)
self.dspacesBox.setPrefix(prefix)
self.dspacesBox.setSuffix(suffix)
def loadSettings(self):
s = QSettings()
s.beginGroup("indent")
self.tabwidthBox.setValue(s.value("tab_width", 8, int))
self.nspacesBox.setValue(s.value("indent_spaces", 2, int))
self.dspacesBox.setValue(s.value("document_spaces", 8, int))
def saveSettings(self):
s = QSettings()
s.beginGroup("indent")
s.setValue("tab_width", self.tabwidthBox.value())
s.setValue("indent_spaces", self.nspacesBox.value())
s.setValue("document_spaces", self.dspacesBox.value())
class NewSensorgroupPage1(QWizardPage):
"""WizardPage to select constructor values"""
def __init__(self, parent, project):
QWizardPage.__init__(self, parent)
self.setTitle(QCoreApplication.translate('DataStorageBrowser',
'Select data import properties'))
self.project = project
self.mainLayout = QGridLayout()
self.setLayout(self.mainLayout)
tsLabel = QLabel(self)
tsLabel.setText(QCoreApplication.translate('DataStorageBrowser', 'Time step'))
self.mainLayout.addWidget(tsLabel, 0, 0)
self.tsInput = QSpinBox(self)
self.tsInput.setSuffix(' s')
self.tsInput.setSpecialValueText('---')
self.tsInput.setMinimum(0)
self.tsInput.setMaximum(86400)
self.tsInput.setValue(0)
self.registerField('timestep', self.tsInput, 'value')
self.mainLayout.addWidget(self.tsInput, 0, 1)
tzLabel = QLabel(self)
tzLabel.setText(QCoreApplication.translate('DataStorageBrowser', 'Time zone'))
self.mainLayout.addWidget(tzLabel, 1, 0)
self.tzInput = QSpinBox(self)
self.tzInput.setMinimum(0)
self.tzInput.setMaximum(23)
self.tzInput.setSuffix(' h')
self.tzInput.setValue(0)
self.registerField('timezone', self.tzInput, 'value')
self.mainLayout.addWidget(self.tzInput, 1, 1)
tfLabel = QLabel(self)
tfLabel.setText(QCoreApplication.translate('DataStorageBrowser', 'Time format'))
self.mainLayout.addWidget(tfLabel, 2, 0)
self.tfInput = QLineEdit(self)
self.tfInput.setText('')
self.registerField('timeformat', self.tfInput, 'text')
self.mainLayout.addWidget(self.tfInput, 2, 1)
self.delimLabel = QLabel(self)
self.delimLabel.setText(QCoreApplication.translate('DataStorageBrowser',
'CSV separator'))
self.mainLayout.addWidget(self.delimLabel, 3, 0)
self.delimInput = QLineEdit(self)
self.delimInput.setMaxLength(1)
self.delimInput.setText(';')
self.registerField('delim', self.delimInput, 'text')
self.mainLayout.addWidget(self.delimInput, 3, 1)
self.tcolLabel = QLabel(self)
self.tcolLabel.setText(QCoreApplication.translate('DataStorageBrowser',
'CSV time column'))
self.mainLayout.addWidget(self.tcolLabel, 4, 0)
self.tcolInput = QSpinBox(self)
self.tcolInput.setMinimum(1)
self.tcolInput.setMaximum(500)
self.tcolInput.setValue(2)
self.registerField('timecol', self.tcolInput, 'value')
self.mainLayout.addWidget(self.tcolInput, 4, 1)
self.extraLabel = QLabel(self)
self.extraLabel.setText(QCoreApplication.translate('DataStorageBrowser',
'CSV extra headers'))
self.mainLayout.addWidget(self.extraLabel, 5, 0)
self.extraInput = QLineEdit(self)
self.extraInput.setMaxLength(200)
self.extraInput.setText('Device;Unit;SensorType')
self.registerField('extra_headers', self.extraInput, 'text')
self.mainLayout.addWidget(self.extraInput, 5, 1)
def initializePage(self):
t = str(self.field('type').toString())
if t == 'CSV':
self.tfInput.setText('%d.%m.%Y %H:%M')
for w in (self.delimLabel, self.delimInput, self.tcolLabel, self.tcolInput,
self.extraLabel, self.extraInput):
w.show()
elif t == 'Remus':
self.tfInput.setText('%d.%m.%y %H:%M:%S')
for w in (self.delimLabel, self.delimInput, self.tcolLabel, self.tcolInput,
self.extraLabel, self.extraInput):
w.hide()
else:
raise SimuVis4.Errors.NotImplementedError
def validatePage(self):
return True
class TabLaTeX(Panel_simple):
titre = u"Tableaux LaTeX" # Donner un titre a chaque module
def __init__(self, *args, **kw):
Panel_simple.__init__(self, *args, **kw)
self.sizer = QVBoxLayout()
self.entree = LigneCommande(self, longueur = 500, action = self.generer_code)
self.sizer.addWidget(self.entree)
self.sizer_type = QHBoxLayout()
self.type_tableau = QComboBox(self)
self.type_tableau.addItems([u"Tableau de variations", u"Tableau de signes",
u"Tableau de valeurs"])
self.type_tableau.setCurrentIndex(self._param_.mode)
self.sizer_type.addWidget(QLabel(u"Type de tableau :", self))
self.sizer_type.addWidget(self.type_tableau)
self.sizer_type.addSpacing(15)
self.utiliser_cellspace = QCheckBox(u"Utiliser le paquetage cellspace.", self)
self.utiliser_cellspace.setChecked(self._param_.utiliser_cellspace)
self.utiliser_cellspace.setToolTip(u"Le paquetage cellspace évite que "
"certains objets (comme les fractions) touchent les bordures du tableaux.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.utiliser_cellspace)
self.derivee = QCheckBox(u"Dérivée.", self)
self.derivee.setChecked(self._param_.derivee)
self.derivee.setToolTip(u"Afficher une ligne indiquant le signe de la dérivée.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.derivee)
self.limites = QCheckBox(u"Limites.", self)
self.limites.setChecked(self._param_.limites)
self.limites.setToolTip(u"Afficher les limites dans le tableau de variations.")
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.limites)
self.decimales_tabvar = QSpinBox()
self.decimales_tabvar.setRange(-1, 20)
self.decimales_tabvar.setSuffix(u" décimales")
self.decimales_tabvar.setSpecialValueText(u"Valeurs exactes")
self.decimales_tabvar.setValue(self._param_.decimales_tabvar)
##self.decimales_tabvar.setAccelerated(True)
aide = u"Nombre de décimales pour l'affichage des extrema, ou valeur exacte."
self.decimales_tabvar.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.decimales_tabvar)
self.decimales_tabval = QSpinBox()
self.decimales_tabval.setRange(0, 20)
self.decimales_tabval.setSuffix(u" décimales")
self.decimales_tabval.setValue(self._param_.decimales_tabval)
##self.decimales_tabval.setAccelerated(True)
aide = u"Nombre de décimales pour les valeurs du tableau."
self.decimales_tabval.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.decimales_tabval)
self.sizer_type.addSpacing(15)
self.lbl_formatage = lbl = QLabel(u"Formatage des résultats :")
self.sizer_type.addWidget(lbl)
self.formatage_images = QLineEdit()
##self.formatage_images.setMinimumWidth(200)
self.formatage_images.setText(self._param_.formatage_images)
aide = u"Formatage à appliquer au résultat (VAL est la valeur du résultat)."
lbl.setToolTip(aide)
self.formatage_images.setToolTip(aide)
self.sizer_type.addSpacing(10)
self.sizer_type.addWidget(self.formatage_images)
self.sizer_type.addStretch()
self.sizer.addLayout(self.sizer_type)
box = QGroupBox(u"Code LaTeX permettant de de générer le tableau", self)
self.bsizer = QVBoxLayout()
box.setLayout(self.bsizer)
self.code_tableau = QTextEdit(self)
self.code_tableau.setMinimumSize(700, 200)
self.code_tableau.setReadOnly(True)
self.bsizer.addWidget(self.code_tableau)
self.copier_code = QPushButton(u"Copier dans le presse-papier", self)
self.bsizer.addWidget(self.copier_code)
txt = u"Pensez à rajouter dans l'entête de votre fichier LaTeX la ligne suivante :"
self.bsizer.addWidget(QLabel(txt, self))
self.sizer_entete = QHBoxLayout()
self.code_entete = QLineEdit(self)
self.code_entete.setMinimumWidth(200)
self.code_entete.setReadOnly(True)
self.code_entete.setText(u"\\usepackage{tabvar}")
self.sizer_entete.addWidget(self.code_entete)
self.copier_entete = QPushButton(u"Copier cette ligne", self)
self.sizer_entete.addWidget(self.copier_entete)
self.bsizer.addLayout(self.sizer_entete)
self.sizer.addWidget(box)
self.cb = QCheckBox(u"Copier automatiquement le code LaTeX dans le presse-papier.", self)
self.cb.setChecked(self._param_.copie_automatique)
self.sizer.addWidget(self.cb)
self.setLayout(self.sizer)
self.adjustSize()
self.type_tableau.currentIndexChanged.connect(self.EvtChoix)
self.EvtChoix()
def copier_code():
return self.vers_presse_papier(self.code_tableau.toPlainText())
self.copier_code.clicked.connect(copier_code)
def copier_entete():
return self.vers_presse_papier(self.code_entete.text())
self.copier_entete.clicked.connect(copier_entete)
def regler_mode_copie():
self._param_.copie_automatique = self.cb.isChecked()
if self._param_.copie_automatique:
copier_code()
self.cb.stateChanged.connect(regler_mode_copie)
def regler_cellspace():
self._param_.utiliser_cellspace = self.utiliser_cellspace.isChecked()
if self._param_.utiliser_cellspace:
self.code_entete.setText(u"\\usepackage{cellspace}")
else:
self.code_entete.setText(u"")
self.valider()
self.utiliser_cellspace.stateChanged.connect(regler_cellspace)
def regler_parametres(event=None):
self._param_.derivee = self.derivee.isChecked()
self._param_.limites = self.limites.isChecked()
self._param_.formatage_images = self.formatage_images.text()
self.valider()
def regler_decimales(event=None):
try:
self.focus_widget = app.focusWidget()
self._param_.decimales_tabvar = self.decimales_tabvar.value()
self._param_.decimales_tabval = self.decimales_tabval.value()
self.valider()
finally:
self.focus_widget = self.entree
self.derivee.stateChanged.connect(regler_parametres)
self.limites.stateChanged.connect(regler_parametres)
self.formatage_images.editingFinished.connect(regler_parametres)
self.decimales_tabvar.valueChanged.connect(regler_decimales)
self.decimales_tabval.valueChanged.connect(regler_decimales)
self.focus_widget = self.entree
def activer(self):
Panel_simple.activer(self)
# Actions à effectuer lorsque l'onglet devient actif
self.entree.setFocus()
def generer_code(self, commande, **kw):
if not commande.strip():
return
# Utilisé pour la sauvegarde automatique:x+3
self.modifie = True
try:
if self._param_.mode == 0:
code_latex = tabvar(commande, derivee=self._param_.derivee,
limites=self._param_.limites,
decimales=self._param_.decimales_tabvar,
approche=(self._param_.decimales_tabvar != -1))
elif self._param_.mode == 1:
code_latex = tabsign(commande, cellspace=self._param_.utiliser_cellspace)
elif self._param_.mode == 2:
code_latex = tabval(commande,
formatage_antecedents=self._param_.formatage_antecedents,
formatage_images=self._param_.formatage_images,
precision=10**-self._param_.decimales_tabval)
else:
warning("Type de tableau non reconnu.")
self.code_tableau.setText(code_latex)
if self._param_.copie_automatique:
self.vers_presse_papier(texte = code_latex)
self.focus_widget.setFocus()
self.message(u"Le code LaTeX a bien été généré.")
except BaseException, erreur:
self.message(u"Impossible de générer le code LaTeX. " + message(erreur))
self.code_tableau.setText(u"<i><b>Erreur.</b> Impossible de générer le code LaTeX.</i>")
self.entree.setFocus()
if param.debug:
raise
