From: pascale.noyret
Date: Mon, 7 Mar 2016 10:58:17 +0000 (+0100)
Subject: mse a jour du 07/03/2016 pour sauvegarde
X-Git-Tag: V8_1_0~40
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=42895950e564e837c445896b5bac263370bdf37b;p=tools%2Feficas.git
mse a jour du 07/03/2016 pour sauvegarde
---
diff --git a/CarmelCND/qtEficas_CarmelCND.py b/CarmelCND/qtEficas_CarmelCND.py
index b1254f2c..f49b9bcb 100755
--- a/CarmelCND/qtEficas_CarmelCND.py
+++ b/CarmelCND/qtEficas_CarmelCND.py
@@ -27,7 +27,6 @@
import sys,os
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
-from PyQt4.QtCore import *
import prefs
from InterfaceQT4 import eficas_go
eficas_go.lance_eficas(code=prefs.code)
diff --git a/Extensions/localisation.py b/Extensions/localisation.py
index f9d0e6d4..25e1e2e6 100644
--- a/Extensions/localisation.py
+++ b/Extensions/localisation.py
@@ -18,10 +18,13 @@
Creates and loads two ``QTranslator`` objects, one for pure Qt, one for Eficas,
and installs them to a ``QApplication``.
-``PyQt4`` is currently supported.
"""
-from PyQt4.QtCore import QTranslator
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtCore import QTranslator
+else :
+ from PyQt4.QtCore import QTranslator
qt_translator = QTranslator()
eficas_translator = QTranslator()
@@ -40,9 +43,15 @@ def localise(application, locale=None ):
If no locale is specified by the user, the system locale
is used instead, for both Qt base and Eficas translators.
"""
- from PyQt4.QtCore import QLibraryInfo
- from PyQt4.QtCore import QLocale
- from PyQt4.QtGui import QApplication
+ if monEnvQT5 :
+ from PyQt5.QtCore import QLibraryInfo
+ from PyQt5.QtCore import QLocale
+ from PyQt5.QtWidgets import QApplication
+ else :
+ from PyQt4.QtCore import QLibraryInfo
+ from PyQt4.QtCore import QLocale
+ from PyQt4.QtGui import QApplication
+
sys_locale = QLocale.system().name()
if locale is None:
diff --git a/Extensions/translation.py b/Extensions/translation.py
index ba4940f4..75cd3302 100644
--- a/Extensions/translation.py
+++ b/Extensions/translation.py
@@ -1,295 +1,7 @@
-# -*- coding: utf-8 -*-
-# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr -- mailto:contact@logilab.fr
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 2.1 of the License, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with this program. If not, see .
-"""
-Main module of the ``i18n`` package, for internationalizing strings via the Qt
-mechanism, in the ``Eficas`` application of EDF. Handles unformatted and
-formatted strings, according to all formatting schemes: via dictionaries,
-tuples, or atoms.
-
-``PyQt4`` is currently supported.
-"""
-from Extensions.eficas_exception import EficasException
-def _reformat_qstring_from_tuple(qstring, params):
- """
- _reformat_qstring_from_tuple(QString, tuple) -> QString
-
- Module-internal method.
- Returns a formatted QString from an unformatted QString
- and a tuple specifying the parameters of the QString.
- """
- from PyQt4.QtCore import QRegExp, QString
- reg = QRegExp("\%\.[1-9]{1,2}f")
- for p, j in zip(params, range(len(params))):
- try:
- i += 1 + qstring[i + 1:].indexOf("%")
- except NameError:
- i = qstring.indexOf("%")
- if i == reg.indexIn(qstring):
- precision = reg.cap(0).split('.')[1].split('f')[0]
- qstring = qstring[:i + 2 + len(precision)].\
- replace("%." + precision, "%" + unicode(1 + j)) + \
- qstring[i + 3 + len(precision):]
- qstring = qstring.arg(QString.number(float(params[j]), 'f',\
- int(precision)))
- else:
- qstring = qstring[:i + 1].replace("%", "%" + unicode(1 + j)) + \
- qstring[i + 2:]
- if isinstance(params[j], unicode):
- qstring = qstring.arg(params[j])
- elif isinstance(params[j], float):
- qstring = qstring.arg(QString.number(params[j], 'f',\
- len(unicode(params[j]).\
- split('.')[1])))
- elif isinstance(params[j], int):
- qstring = qstring.arg(QString.number(params[j], 10))
- elif isinstance(params[j], list):
- qstring = qstring.arg(repr(params[j]))
- else:
- raise EficasException("TypeError: i18n.translation: \
- Unicode, list or number expected!")
- return qstring
-
-def _reformat_qstring_from_dict(qstring, params):
- """
- _reformat_qstring_from_dict(QString, dict) -> QString
-
- Module-internal method.
- Returns a formatted QString from an unformatted QString
- and a dictionary specifying the parameters of the QString.
- """
- from PyQt4.QtCore import QRegExp, QString
- for p, j in zip(params, range(len(params))):
- p_reg = QRegExp("\%\("+ p + "\)\.[1-9]{1,2}f")
- p_index = p_reg.indexIn(qstring)
- if p_index != -1:
- precision = p_reg.cap(0).split('.')[1].split('f')[0]
- qstring = qstring.replace("%(" + p + ")." + precision + "f",\
- "%" + unicode(1 + j)).\
- arg(QString.number(float(params[p]), \
- 'f', \
- int(precision)))
- else:
- qstring.remove(QRegExp("\\)[sdf]{1}"))
- qstring = qstring.replace("%(" + p, "%" + unicode(1 + j))
- if isinstance(params[p], unicode):
- qstring = qstring.arg(params[p])
- elif isinstance(params[p], float):
- qstring = qstring.arg(QString.number(params[p], 'f', \
- len(unicode(params[p]).split('.')[1])))
- elif isinstance(params[p], int):
- qstring = qstring.arg(QString.number(params[p], 10))
- elif isinstance(params[p], list):
- qstring = qstring.arg(repr(params[p]))
- else:
- raise EficasException("TypeError: i18n.translation: \
- Improper string parameter type.")
- return qstring
-
-def _reformat_qstring_from_atom(qstring, params):
- """
- _reformat_qstring_from_atom(QString, int-or-float) -> QString
-
- Module-internal method.
- Returns a formatted QString from an unformatted QString
- and an integer or a float specifying the parameter of
- the QString.
- """
- from PyQt4.QtCore import QRegExp, QString
- reg = QRegExp("\%\.[1-9]{1,2}f")
- if qstring.count("%") == 0:
- qstring.append("%1")
- try:
- qstring = qstring.arg(unicode(params))
- except AttributeError:
- qstring = qstring.arg(params)
- elif qstring.count("%") == 1:
- i = qstring.indexOf("%")
- if i == reg.indexIn(qstring):
- precision = reg.cap(0).split('.')[1].split('f')[0]
- qstring = qstring[: i + 2 + len(precision)].\
- replace("%." + precision, "%1") + \
- qstring[i + 3 + len(precision):]
- qstring = qstring.arg(QString.number(float(params), 'f',\
- int(precision)))
- else:
- qstring = qstring[:i + 1].replace("%", "%1") + \
- qstring[i + 2:]
- if isinstance(params, (unicode, str)):
- qstring = qstring.arg(_preprocess_atom(params))
- elif isinstance(params, float):
- qstring = qstring.arg(QString.number(params, 'f', \
- len(unicode(params).\
- split('.')[1])))
- elif isinstance(params, int):
- qstring = qstring.arg(QString.number(params, 10))
- else:
- raise EficasException("TypeError: i18n.translation: Unicode, \
- string or number expected!")
- return qstring
-
-def _reformat_qstring_from_list(qstring, params):
- """
- _reformat_qstring_from_list(QString, tuple) -> QString
-
- Module-internal method.
- Returns a formatted QString from an unformatted QString
- and a list whose concatenation specifies the parameter
- of the QString.
- """
- # XXX to add further functionality, e.g. list processing
- # when ``%`` not at the end.
- if qstring.count("%") == 1 and \
- unicode(qstring).strip()[:-1].endswith("%"):
- qstring = qstring[:qstring.indexOf("%") + 1].append("1")
- qstring = qstring.arg(u' '.join(map(unicode, params)))
- elif qstring.count("%") == 0:
- qstring.append("%1")
- qstring = qstring.arg(u' '.join(map(unicode, params)))
- else:
- raise EficasException("ValueError: i18n.translation: \
- At most one '%' expected!")
- return qstring
-
-def _preprocess_atom(string):
- """
- _preprocess_atom(string-or-number-or-unicode) -> unicode
- Test if input is a Unicode object or a number; if so, then return it;
- otherwise, test if the input is a string; if so, then try to create
- a Unicode object out of it. To this end, assume the string is encoded
- in utf-8; if this fails, then assume the string is encoded in Latin-9.
- """
- if isinstance(string, (unicode, int, float, complex)):
- return string
- elif isinstance(string, str):
- return _str_to_unicode(string)
- else:
- raise EficasException("TypeError: Expected number, string or\
- Unicode object!")
-
-def _str_to_unicode(string):
- """
- _str_to_unicode(string) -> unicode
- Tries to create a Unicode object out of the input string; assumes
- the string is UTF-8 encoded; if not, then assume the string is
- Latin-9 encoded.
- """
- try:
- string = unicode(string, "utf-8")
- except UnicodeDecodeError:
- try:
- string = unicode(string, "iso-8859-15")
- except UnicodeDecodeError:
- raise EficasException("UnicodeDecodeError: UTF-8, Latin-1 \
- or Latin-9 expected")
- return string
-
-def tr(string, *args):
- """tr(string-or-unicode, iterable-or-float-or-int) -> unicode
- tr(string-or-unicode) -> unicode
-
- Returns a formatted Unicode object from an unformatted
- string or Unicode object with formatting specifications, and,
- optionally, an iterable or an int or float.
- Lets Python do the string formatting."""
- from PyQt4.QtGui import QApplication
- string = _preprocess_atom(string)
- if len(args) == 0:
- r = unicode(QApplication.translate("@default", string))
- elif len(args) == 1:
- if isinstance(args[0], (dict, tuple)):
- if string.count("%") == len(args[0]):
- r = unicode(QApplication.translate("@default", string)) % args[0]
- elif string.count("%") == 1 and string.count("%(") == 0:
- r = unicode(QApplication.translate("@default", string))\
- % _preprocess_atom(repr(args[0]))
- elif string.count("%") == 0:
- r = (unicode(QApplication.translate("@default", string)), args[0])
- else:
- raise EficasException("ValueError: i18n.translate.tr: \
- Improper input string formatting")
- elif isinstance(args[0], (unicode, str, int, float, complex)):
- if string.count("%") == 1:
- r = unicode(QApplication.translate("@default", string))\
- % _preprocess_atom(args[0])
- else:
- r = unicode(QApplication.translate("@default", string)) +\
- unicode(_preprocess_atom(args[0]))
- elif isinstance(args[0], list) or args[0] is None:
- if string.count("%") == 1:
- r = unicode(QApplication.translate("@default", string))\
- % _preprocess_atom(repr(args[0]))
- else:
- r = (unicode(QApplication.translate("@default", string)), args[0])
-
- else:
- raise EficasException("ValueError: i18n.translation.tr: \
- Wrong type for formatted string \
- arguments: %s" % type(args[0]))
- else:
- raise EficasException("ValueError: i18n.translation.tr: \
- Wrong formatted string arguments")
- return r
-
-
-def tr_qt(string, *args):
- """tr_qt(string, iterable-or-float-or-int) -> unicode
- t_qtr(string) -> unicode
-
- Returns a formatted string from an unformatted
- Unicode string with formatting specifications, and,
- optionally, an iterable or an int or float.
- Lets PyQt4 do the string formatting. To this end,
- a conversion from Python to Qt string formatting
- syntax is performed."""
- string = _preprocess_atom(string)
- from PyQt4.QtGui import QApplication
- if len(args) == 0:
- r = QApplication.translate("@default", string)
- elif len(args) == 1:
- r = QApplication.translate("@default", string)
- if isinstance(args[0], (dict, tuple)):
- if r.count("%") == len(args[0]):
- if isinstance(args[0], dict):
- r = _reformat_qstring_from_dict(r, args[0])
- elif isinstance(args[0], tuple):
- r = _reformat_qstring_from_tuple(r, args[0])
- # XXX Pay attention to this: distinguish between tuple,
- # dict and dict with key given in string.
- elif r.count("%") in range(2) and r.count("%(") == 0:
- r = _reformat_qstring_from_atom(r, _preproces_atom(repr(args[0])))
- else:
- raise EficasException("ValueError: i18n.translation.tr_qt: \
- Improper formatting string parameters")
- elif isinstance(args[0], (unicode, str, int, float, complex)):
- r = _reformat_qstring_from_atom(r, args[0])
- elif isinstance(args[0], list):
- r = _reformat_qstring_from_list(r, args[0])
- elif args[0] is None:
- r = _reformat_qstring_from_atom(r, _preprocess_string_from_atom(repr(args[0])))
- else:
- raise EficasException("ValueError: i18n.translation.tr_qt: \
- Wrong string formatting parameter types")
- else:
- raise EficasException("ValueError: i18n.translation.tr_qt: \
- Improper formatted string parameter set")
- return unicode(r)
-
-
-if __name__ == "__main__":
- import sys
- tr(sys.argv[1], *args)
- tr_qt(sys.argv[1], *args)
+from determine import monEnvQT5
+if monEnvQT5 :
+ from translationQT5 import tr
+ from translationQT5 import tr_qt
+else :
+ from translationQT4 import tr
+ from translationQT4 import tr_qt
diff --git a/Extensions/translationQT4.py b/Extensions/translationQT4.py
new file mode 100644
index 00000000..ba4940f4
--- /dev/null
+++ b/Extensions/translationQT4.py
@@ -0,0 +1,295 @@
+# -*- coding: utf-8 -*-
+# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr -- mailto:contact@logilab.fr
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program. If not, see .
+"""
+Main module of the ``i18n`` package, for internationalizing strings via the Qt
+mechanism, in the ``Eficas`` application of EDF. Handles unformatted and
+formatted strings, according to all formatting schemes: via dictionaries,
+tuples, or atoms.
+
+``PyQt4`` is currently supported.
+"""
+from Extensions.eficas_exception import EficasException
+def _reformat_qstring_from_tuple(qstring, params):
+ """
+ _reformat_qstring_from_tuple(QString, tuple) -> QString
+
+ Module-internal method.
+ Returns a formatted QString from an unformatted QString
+ and a tuple specifying the parameters of the QString.
+ """
+ from PyQt4.QtCore import QRegExp, QString
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ for p, j in zip(params, range(len(params))):
+ try:
+ i += 1 + qstring[i + 1:].indexOf("%")
+ except NameError:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split('.')[1].split('f')[0]
+ qstring = qstring[:i + 2 + len(precision)].\
+ replace("%." + precision, "%" + unicode(1 + j)) + \
+ qstring[i + 3 + len(precision):]
+ qstring = qstring.arg(QString.number(float(params[j]), 'f',\
+ int(precision)))
+ else:
+ qstring = qstring[:i + 1].replace("%", "%" + unicode(1 + j)) + \
+ qstring[i + 2:]
+ if isinstance(params[j], unicode):
+ qstring = qstring.arg(params[j])
+ elif isinstance(params[j], float):
+ qstring = qstring.arg(QString.number(params[j], 'f',\
+ len(unicode(params[j]).\
+ split('.')[1])))
+ elif isinstance(params[j], int):
+ qstring = qstring.arg(QString.number(params[j], 10))
+ elif isinstance(params[j], list):
+ qstring = qstring.arg(repr(params[j]))
+ else:
+ raise EficasException("TypeError: i18n.translation: \
+ Unicode, list or number expected!")
+ return qstring
+
+def _reformat_qstring_from_dict(qstring, params):
+ """
+ _reformat_qstring_from_dict(QString, dict) -> QString
+
+ Module-internal method.
+ Returns a formatted QString from an unformatted QString
+ and a dictionary specifying the parameters of the QString.
+ """
+ from PyQt4.QtCore import QRegExp, QString
+ for p, j in zip(params, range(len(params))):
+ p_reg = QRegExp("\%\("+ p + "\)\.[1-9]{1,2}f")
+ p_index = p_reg.indexIn(qstring)
+ if p_index != -1:
+ precision = p_reg.cap(0).split('.')[1].split('f')[0]
+ qstring = qstring.replace("%(" + p + ")." + precision + "f",\
+ "%" + unicode(1 + j)).\
+ arg(QString.number(float(params[p]), \
+ 'f', \
+ int(precision)))
+ else:
+ qstring.remove(QRegExp("\\)[sdf]{1}"))
+ qstring = qstring.replace("%(" + p, "%" + unicode(1 + j))
+ if isinstance(params[p], unicode):
+ qstring = qstring.arg(params[p])
+ elif isinstance(params[p], float):
+ qstring = qstring.arg(QString.number(params[p], 'f', \
+ len(unicode(params[p]).split('.')[1])))
+ elif isinstance(params[p], int):
+ qstring = qstring.arg(QString.number(params[p], 10))
+ elif isinstance(params[p], list):
+ qstring = qstring.arg(repr(params[p]))
+ else:
+ raise EficasException("TypeError: i18n.translation: \
+ Improper string parameter type.")
+ return qstring
+
+def _reformat_qstring_from_atom(qstring, params):
+ """
+ _reformat_qstring_from_atom(QString, int-or-float) -> QString
+
+ Module-internal method.
+ Returns a formatted QString from an unformatted QString
+ and an integer or a float specifying the parameter of
+ the QString.
+ """
+ from PyQt4.QtCore import QRegExp, QString
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ if qstring.count("%") == 0:
+ qstring.append("%1")
+ try:
+ qstring = qstring.arg(unicode(params))
+ except AttributeError:
+ qstring = qstring.arg(params)
+ elif qstring.count("%") == 1:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split('.')[1].split('f')[0]
+ qstring = qstring[: i + 2 + len(precision)].\
+ replace("%." + precision, "%1") + \
+ qstring[i + 3 + len(precision):]
+ qstring = qstring.arg(QString.number(float(params), 'f',\
+ int(precision)))
+ else:
+ qstring = qstring[:i + 1].replace("%", "%1") + \
+ qstring[i + 2:]
+ if isinstance(params, (unicode, str)):
+ qstring = qstring.arg(_preprocess_atom(params))
+ elif isinstance(params, float):
+ qstring = qstring.arg(QString.number(params, 'f', \
+ len(unicode(params).\
+ split('.')[1])))
+ elif isinstance(params, int):
+ qstring = qstring.arg(QString.number(params, 10))
+ else:
+ raise EficasException("TypeError: i18n.translation: Unicode, \
+ string or number expected!")
+ return qstring
+
+def _reformat_qstring_from_list(qstring, params):
+ """
+ _reformat_qstring_from_list(QString, tuple) -> QString
+
+ Module-internal method.
+ Returns a formatted QString from an unformatted QString
+ and a list whose concatenation specifies the parameter
+ of the QString.
+ """
+ # XXX to add further functionality, e.g. list processing
+ # when ``%`` not at the end.
+ if qstring.count("%") == 1 and \
+ unicode(qstring).strip()[:-1].endswith("%"):
+ qstring = qstring[:qstring.indexOf("%") + 1].append("1")
+ qstring = qstring.arg(u' '.join(map(unicode, params)))
+ elif qstring.count("%") == 0:
+ qstring.append("%1")
+ qstring = qstring.arg(u' '.join(map(unicode, params)))
+ else:
+ raise EficasException("ValueError: i18n.translation: \
+ At most one '%' expected!")
+ return qstring
+
+def _preprocess_atom(string):
+ """
+ _preprocess_atom(string-or-number-or-unicode) -> unicode
+ Test if input is a Unicode object or a number; if so, then return it;
+ otherwise, test if the input is a string; if so, then try to create
+ a Unicode object out of it. To this end, assume the string is encoded
+ in utf-8; if this fails, then assume the string is encoded in Latin-9.
+ """
+ if isinstance(string, (unicode, int, float, complex)):
+ return string
+ elif isinstance(string, str):
+ return _str_to_unicode(string)
+ else:
+ raise EficasException("TypeError: Expected number, string or\
+ Unicode object!")
+
+def _str_to_unicode(string):
+ """
+ _str_to_unicode(string) -> unicode
+ Tries to create a Unicode object out of the input string; assumes
+ the string is UTF-8 encoded; if not, then assume the string is
+ Latin-9 encoded.
+ """
+ try:
+ string = unicode(string, "utf-8")
+ except UnicodeDecodeError:
+ try:
+ string = unicode(string, "iso-8859-15")
+ except UnicodeDecodeError:
+ raise EficasException("UnicodeDecodeError: UTF-8, Latin-1 \
+ or Latin-9 expected")
+ return string
+
+def tr(string, *args):
+ """tr(string-or-unicode, iterable-or-float-or-int) -> unicode
+ tr(string-or-unicode) -> unicode
+
+ Returns a formatted Unicode object from an unformatted
+ string or Unicode object with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets Python do the string formatting."""
+ from PyQt4.QtGui import QApplication
+ string = _preprocess_atom(string)
+ if len(args) == 0:
+ r = unicode(QApplication.translate("@default", string))
+ elif len(args) == 1:
+ if isinstance(args[0], (dict, tuple)):
+ if string.count("%") == len(args[0]):
+ r = unicode(QApplication.translate("@default", string)) % args[0]
+ elif string.count("%") == 1 and string.count("%(") == 0:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(repr(args[0]))
+ elif string.count("%") == 0:
+ r = (unicode(QApplication.translate("@default", string)), args[0])
+ else:
+ raise EficasException("ValueError: i18n.translate.tr: \
+ Improper input string formatting")
+ elif isinstance(args[0], (unicode, str, int, float, complex)):
+ if string.count("%") == 1:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(args[0])
+ else:
+ r = unicode(QApplication.translate("@default", string)) +\
+ unicode(_preprocess_atom(args[0]))
+ elif isinstance(args[0], list) or args[0] is None:
+ if string.count("%") == 1:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(repr(args[0]))
+ else:
+ r = (unicode(QApplication.translate("@default", string)), args[0])
+
+ else:
+ raise EficasException("ValueError: i18n.translation.tr: \
+ Wrong type for formatted string \
+ arguments: %s" % type(args[0]))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr: \
+ Wrong formatted string arguments")
+ return r
+
+
+def tr_qt(string, *args):
+ """tr_qt(string, iterable-or-float-or-int) -> unicode
+ t_qtr(string) -> unicode
+
+ Returns a formatted string from an unformatted
+ Unicode string with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets PyQt4 do the string formatting. To this end,
+ a conversion from Python to Qt string formatting
+ syntax is performed."""
+ string = _preprocess_atom(string)
+ from PyQt4.QtGui import QApplication
+ if len(args) == 0:
+ r = QApplication.translate("@default", string)
+ elif len(args) == 1:
+ r = QApplication.translate("@default", string)
+ if isinstance(args[0], (dict, tuple)):
+ if r.count("%") == len(args[0]):
+ if isinstance(args[0], dict):
+ r = _reformat_qstring_from_dict(r, args[0])
+ elif isinstance(args[0], tuple):
+ r = _reformat_qstring_from_tuple(r, args[0])
+ # XXX Pay attention to this: distinguish between tuple,
+ # dict and dict with key given in string.
+ elif r.count("%") in range(2) and r.count("%(") == 0:
+ r = _reformat_qstring_from_atom(r, _preproces_atom(repr(args[0])))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Improper formatting string parameters")
+ elif isinstance(args[0], (unicode, str, int, float, complex)):
+ r = _reformat_qstring_from_atom(r, args[0])
+ elif isinstance(args[0], list):
+ r = _reformat_qstring_from_list(r, args[0])
+ elif args[0] is None:
+ r = _reformat_qstring_from_atom(r, _preprocess_string_from_atom(repr(args[0])))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Wrong string formatting parameter types")
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Improper formatted string parameter set")
+ return unicode(r)
+
+
+if __name__ == "__main__":
+ import sys
+ tr(sys.argv[1], *args)
+ tr_qt(sys.argv[1], *args)
diff --git a/Extensions/translationQT5.py b/Extensions/translationQT5.py
new file mode 100644
index 00000000..565cec79
--- /dev/null
+++ b/Extensions/translationQT5.py
@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr -- mailto:contact@logilab.fr
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program. If not, see .
+"""
+Main module of the ``i18n`` package, for internationalizing strings via the Qt
+mechanism, in the ``Eficas`` application of EDF. Handles unformatted and
+formatted strings, according to all formatting schemes: via dictionaries,
+tuples, or atoms.
+
+``PyQt4`` is currently supported.
+"""
+from Extensions.eficas_exception import EficasException
+import re
+regex=re.compile(r"% *[0-9]+")
+
+
+
+
+def _reformat_qstring_from_tuple(qstring, params):
+ """
+ _reformat_qstring_from_tuple(string, tuple) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a tuple specifying the parameters of the string.
+ """
+ from PyQt5.QtCore import QRegExp
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ for p, j in zip(params, range(len(params))):
+ try:
+ i += 1 + qstring[i + 1:].indexOf("%")
+ except NameError:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split('.')[1].split('f')[0]
+ qstring = qstring[:i + 2 + len(precision)].\
+ replace("%." + precision, "%" + unicode(1 + j)) + \
+ qstring[i + 3 + len(precision):]
+ qstring=regex.sub("{}",qstring)
+ #qstring = qstring.format(QString.number(float(params[j]), 'f', int(precision)))
+ qstring = qstring.format(float(params[j]))
+ else:
+ qstring = qstring[:i + 1].replace("%", "%" + unicode(1 + j)) + \
+ qstring[i + 2:]
+ if isinstance(params[j], unicode):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], float):
+ qstring=regex.sub("{}",qstring)
+ #qstring = qstring.format(QString.number(params[j], 'f',\ len(unicode(params[j]).\
+ # split('.')[1])))
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], int):
+ qstring=regex.sub("{}",qstring)
+ #qstring = qstring.format(QString.number(params[j], 10))
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], list):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(repr(params[j]))
+ else:
+ raise EficasException("TypeError: i18n.translation: \
+ Unicode, list or number expected!")
+ return qstring
+
+def _reformat_qstring_from_dict(qstring, params):
+ """
+ _reformat_qstring_from_dict(string, dict) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a dictionary specifying the parameters of the string.
+ """
+ from PyQt5.QtCore import QRegExp
+ for p, j in zip(params, range(len(params))):
+ p_reg = QRegExp("\%\("+ p + "\)\.[1-9]{1,2}f")
+ p_index = p_reg.indexIn(qstring)
+ if p_index != -1:
+ precision = p_reg.cap(0).split('.')[1].split('f')[0]
+ #qstring = qstring.replace("%(" + p + ")." + precision + "f",\
+ # "%" + unicode(1 + j)).\
+ # arg(QString.number(float(params[p]), \
+ # 'f', \
+ # int(precision)))
+ qstring = qstring.replace("%(" + p + ")." + precision + "f","%" + unicode(1 + j))
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(float(params[p]))
+ else:
+ qstring.remove(QRegExp("\\)[sdf]{1}"))
+ qstring = qstring.replace("%(" + p, "%" + unicode(1 + j))
+ if isinstance(params[p], unicode):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(params[p])
+ elif isinstance(params[p], float):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(params[p])
+ #qstring = qstring.format(QString.number(params[p], 'f', \
+ # len(unicode(params[p]).split('.')[1])))
+ elif isinstance(params[p], int):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(params[p])
+ elif isinstance(params[p], list):
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(repr(params[p]))
+ else:
+ raise EficasException("TypeError: i18n.translation: \
+ Improper string parameter type.")
+ return qstring
+
+def _reformat_qstring_from_atom(qstring, params):
+ """
+ _reformat_qstring_from_atom(string, int-or-float) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and an integer or a float specifying the parameter of
+ the string.
+ """
+ from PyQt5.QtCore import QRegExp
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ if qstring.count("%") == 0:
+ qstring.append("%1")
+ try:
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(unicode(params))
+ except AttributeError:
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(params)
+ elif qstring.count("%") == 1:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split('.')[1].split('f')[0]
+ qstring = qstring[: i + 2 + len(precision)].\
+ replace("%." + precision, "%1") + \
+ qstring[i + 3 + len(precision):]
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format((params))
+ #qstring = qstring.format(QString.number(float(params), 'f',\
+ # int(precision)))
+ else:
+ qstring = qstring[:i + 1].replace("%", "%1") + \
+ qstring[i + 2:]
+ if isinstance(params, (unicode, str)):
+ qstring = qstring.format(_preprocess_atom(params))
+ elif isinstance(params, float):
+ #qstring = qstring.format(QString.number(params, 'f', \
+ # len(unicode(params).\
+ # split('.')[1])))
+ qstring = qstring.format(params)
+ elif isinstance(params, int):
+ qstring=regex.sub("{}",qstring)
+ #qstring = qstring.format(QString.number(params, 10))
+ qstring = qstring.format(params)
+ else:
+ raise EficasException("TypeError: i18n.translation: Unicode, \
+ string or number expected!")
+ return qstring
+
+def _reformat_qstring_from_list(qstring, params):
+ """
+ _reformat_qstring_from_list(string, tuple) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a list whose concatenation specifies the parameter
+ of the string.
+ """
+ # XXX to add further functionality, e.g. list processing
+ # when ``%`` not at the end.
+ if qstring.count("%") == 1 and \
+ unicode(qstring).strip()[:-1].endswith("%"):
+ qstring = qstring[:qstring.indexOf("%") + 1].append("1")
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(u' '.join(map(unicode, params)))
+ elif qstring.count("%") == 0:
+ qstring.append("%1")
+ qstring=regex.sub("{}",qstring)
+ qstring = qstring.format(u' '.join(map(unicode, params)))
+ else:
+ raise EficasException("ValueError: i18n.translation: \
+ At most one '%' expected!")
+ return qstring
+
+def _preprocess_atom(string):
+ """
+ _preprocess_atom(string-or-number-or-unicode) -> unicode
+ Test if input is a Unicode object or a number; if so, then return it;
+ otherwise, test if the input is a string; if so, then try to create
+ a Unicode object out of it. To this end, assume the string is encoded
+ in utf-8; if this fails, then assume the string is encoded in Latin-9.
+ """
+ if isinstance(string, (unicode, int, float, complex)):
+ return string
+ elif isinstance(string, str):
+ return _str_to_unicode(string)
+ else:
+ raise EficasException("TypeError: Expected number, string or\
+ Unicode object!")
+
+def _str_to_unicode(string):
+ """
+ _str_to_unicode(string) -> unicode
+ Tries to create a Unicode object out of the input string; assumes
+ the string is UTF-8 encoded; if not, then assume the string is
+ Latin-9 encoded.
+ """
+ try:
+ string = unicode(string, "utf-8")
+ except UnicodeDecodeError:
+ try:
+ string = unicode(string, "iso-8859-15")
+ except UnicodeDecodeError:
+ raise EficasException("UnicodeDecodeError: UTF-8, Latin-1 \
+ or Latin-9 expected")
+ return string
+
+def tr(string, *args):
+ """tr(string-or-unicode, iterable-or-float-or-int) -> unicode
+ tr(string-or-unicode) -> unicode
+
+ Returns a formatted Unicode object from an unformatted
+ string or Unicode object with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets Python do the string formatting."""
+ from PyQt5.QtWidgets import QApplication
+ string = _preprocess_atom(string)
+ if len(args) == 0:
+ r = unicode(QApplication.translate("@default", string))
+ elif len(args) == 1:
+ if isinstance(args[0], (dict, tuple)):
+ if string.count("%") == len(args[0]):
+ r = unicode(QApplication.translate("@default", string)) % args[0]
+ elif string.count("%") == 1 and string.count("%(") == 0:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(repr(args[0]))
+ elif string.count("%") == 0:
+ r = (unicode(QApplication.translate("@default", string)), args[0])
+ else:
+ raise EficasException("ValueError: i18n.translate.tr: \
+ Improper input string formatting")
+ elif isinstance(args[0], (unicode, str, int, float, complex)):
+ if string.count("%") == 1:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(args[0])
+ else:
+ r = unicode(QApplication.translate("@default", string)) +\
+ unicode(_preprocess_atom(args[0]))
+ elif isinstance(args[0], list) or args[0] is None:
+ if string.count("%") == 1:
+ r = unicode(QApplication.translate("@default", string))\
+ % _preprocess_atom(repr(args[0]))
+ else:
+ r = (unicode(QApplication.translate("@default", string)), args[0])
+
+ else:
+ raise EficasException("ValueError: i18n.translation.tr: \
+ Wrong type for formatted string \
+ arguments: %s" % type(args[0]))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr: \
+ Wrong formatted string arguments")
+ return r
+
+
+def tr_qt(string, *args):
+ """tr_qt(string, iterable-or-float-or-int) -> unicode
+ t_qtr(string) -> unicode
+
+ Returns a formatted string from an unformatted
+ Unicode string with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets PyQt4 do the string formatting. To this end,
+ a conversion from Python to Qt string formatting
+ syntax is performed."""
+ string = _preprocess_atom(string)
+ from PyQt5.QtWidgets import QApplication
+ if len(args) == 0:
+ r = QApplication.translate("@default", string)
+ elif len(args) == 1:
+ r = QApplication.translate("@default", string)
+ if isinstance(args[0], (dict, tuple)):
+ if r.count("%") == len(args[0]):
+ if isinstance(args[0], dict):
+ r = _reformat_qstring_from_dict(r, args[0])
+ elif isinstance(args[0], tuple):
+ r = _reformat_qstring_from_tuple(r, args[0])
+ # XXX Pay attention to this: distinguish between tuple,
+ # dict and dict with key given in string.
+ elif r.count("%") in range(2) and r.count("%(") == 0:
+ r = _reformat_qstring_from_atom(r, _preproces_atom(repr(args[0])))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Improper formatting string parameters")
+ elif isinstance(args[0], (unicode, str, int, float, complex)):
+ r = _reformat_qstring_from_atom(r, args[0])
+ elif isinstance(args[0], list):
+ r = _reformat_qstring_from_list(r, args[0])
+ elif args[0] is None:
+ r = _reformat_qstring_from_atom(r, _preprocess_string_from_atom(repr(args[0])))
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Wrong string formatting parameter types")
+ else:
+ raise EficasException("ValueError: i18n.translation.tr_qt: \
+ Improper formatted string parameter set")
+ return unicode(r)
+
+
+if __name__ == "__main__":
+ import sys
+ tr(sys.argv[1], *args)
+ tr_qt(sys.argv[1], *args)
diff --git a/InterfaceQT4/browser.py b/InterfaceQT4/browser.py
index 2745b6b1..ca143810 100644
--- a/InterfaceQT4/browser.py
+++ b/InterfaceQT4/browser.py
@@ -22,10 +22,15 @@ import string,re
import types,sys,os
import traceback
import typeNode
-import pdb
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+#import pdb
+
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QTreeWidget , QTreeWidgetItem
+ from PyQt5.QtGui import QIcon
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
from Extensions.i18n import tr
from gereRegles import GereRegles
from monChoixCommande import MonChoixCommande
@@ -56,9 +61,14 @@ class JDCTree( QTreeWidget,GereRegles ):
self.itemCourrant=None
- self.connect(self, SIGNAL("itemClicked ( QTreeWidgetItem * ,int) "), self.handleOnItem)
- self.connect(self, SIGNAL("itemCollapsed ( QTreeWidgetItem *) "), self.handleCollapsedItem)
- self.connect(self, SIGNAL("itemExpanded ( QTreeWidgetItem *) "), self.handleExpandedItem)
+ if monEnvQT5 :
+ self.itemClicked.connect(self.handleOnItem)
+ self.itemCollapsed.connect(self.handleCollapsedItem)
+ self.itemExpanded.connect(self.handleExpandedItem)
+ else :
+ self.connect(self, SIGNAL("itemClicked ( QTreeWidgetItem * ,int) "), self.handleOnItem)
+ self.connect(self, SIGNAL("itemCollapsed ( QTreeWidgetItem *) "), self.handleCollapsedItem)
+ self.connect(self, SIGNAL("itemExpanded ( QTreeWidgetItem *) "), self.handleExpandedItem)
#PNPNPN verifier dans quel cas on se trouve : affiche l arbre ou la commande
self.node_selected=self.racine
@@ -199,14 +209,18 @@ class JDCNode(QTreeWidgetItem,GereRegles):
from InterfaceQT4 import compoparam
from InterfaceQT4 import composimp
if (isinstance(self.item,compocomm.COMMTreeItem)) : name=tr("Commentaire")
- elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name=self.appliEficas.trUtf8(str(item.GetLabelText()[0]))
- else: name = self.appliEficas.trUtf8(str(tr( item.nom))+" :")
- value = self.appliEficas.trUtf8(str( item.GetText() ) )
+ elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name=tr(str(item.GetLabelText()[0]))
+ else: name = tr(str(tr( item.nom))+" :")
+ value = tr(str( item.GetText() ) )
- mesColonnes=QStringList()
- if self.editor.enteteQTree=='complet': mesColonnes << name << value
- else : mesColonnes << name
+ if monEnvQT5:
+ if self.editor.enteteQTree=='complet':mesColonnes=(name,value)
+ else : mesColonnes=(name,)
+ else :
+ mesColonnes=QStringList()
+ if self.editor.enteteQTree=='complet': mesColonnes << name << value
+ else : mesColonnes << name
if self.treeParent.plie==True :
self.plie = True
@@ -233,10 +247,15 @@ class JDCNode(QTreeWidgetItem,GereRegles):
else :
QTreeWidgetItem.__init__(self,self.treeParent,mesColonnes)
- self.setToolTip(0,QString(self.item.get_fr()))
- self.setToolTip(1,QString(self.item.get_fr()))
+ if monEnvQT5 :
+ self.setToolTip(0,self.item.get_fr())
+ self.setToolTip(1,self.item.get_fr())
+ repIcon=self.appliEficas.repIcon
+ else :
+ self.setToolTip(0,QString(self.item.get_fr()))
+ self.setToolTip(1,QString(self.item.get_fr()))
+ repIcon=QString(self.appliEficas.repIcon)
- repIcon=QString(self.appliEficas.repIcon)
monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
self.setIcon(0,monIcone)
@@ -624,7 +643,8 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""Cette methode remet a jour la validite du noeud (icone)
Elle appelle isvalid
"""
- repIcon=QString(self.appliEficas.repIcon)
+ if monEnvQT5 : repIcon=self.appliEficas.repIcon
+ else : repIcon=QString(self.appliEficas.repIcon)
monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
self.setIcon(0,monIcone)
diff --git a/InterfaceQT4/compobloc.py b/InterfaceQT4/compobloc.py
index cd1c1e29..bed58457 100644
--- a/InterfaceQT4/compobloc.py
+++ b/InterfaceQT4/compobloc.py
@@ -18,8 +18,7 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from PyQt4 import *
-from PyQt4.QtGui import *
+
from Editeur import Objecttreeitem
import compofact
diff --git a/InterfaceQT4/compocomm.py b/InterfaceQT4/compocomm.py
index e87cb443..424baf7c 100644
--- a/InterfaceQT4/compocomm.py
+++ b/InterfaceQT4/compocomm.py
@@ -18,10 +18,15 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
import string
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QAction
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
from Editeur import Objecttreeitem
import browser
import typeNode
@@ -39,7 +44,8 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
def createPopUpMenu(self):
typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
self.Decommente = QAction(tr("Decommenter"),self.tree)
- self.tree.connect(self.Decommente,SIGNAL("triggered()"),self.Decommenter)
+ if monEnvQT5 : self.tree.connect(self.Decommente,SIGNAL("triggered()"),self.Decommenter)
+ else : self.Decommente.triggered(self.Decommenter)
self.Decommente.setStatusTip(tr("Decommente la commande "))
if hasattr(self.item,'uncomment'):
diff --git a/InterfaceQT4/compofact.py b/InterfaceQT4/compofact.py
index c5ee1cdd..ab893a6b 100644
--- a/InterfaceQT4/compofact.py
+++ b/InterfaceQT4/compofact.py
@@ -18,9 +18,6 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
import browser
import typeNode
from Extensions.i18n import tr
diff --git a/InterfaceQT4/compomacro.py b/InterfaceQT4/compomacro.py
index 2bba03e8..e5e6162e 100644
--- a/InterfaceQT4/compomacro.py
+++ b/InterfaceQT4/compomacro.py
@@ -29,8 +29,14 @@ from Extensions.i18n import tr
import compooper
import browser
import typeNode
-from PyQt4.QtGui import QAction
-from PyQt4.QtCore import Qt, SIGNAL, QVariant
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QAction
+ from PyQt5.QtCore import Qt
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
class MACRONode(browser.JDCNode,typeNode.PopUpMenuNode):
@@ -44,7 +50,10 @@ class MACRONode(browser.JDCNode,typeNode.PopUpMenuNode):
typeNode.PopUpMenuNode.createPopUpMenu(self)
if ("AFFE_CARA_ELEM" in self.item.get_genealogie()) and self.editor.salome:
self.ViewElt = QAction(tr('View3D'),self.tree)
- self.tree.connect(self.ViewElt,SIGNAL("triggered()"),self.view3D)
+ if monEnvQT5:
+ self.ViewElt.triggered.connect(self.View3D)
+ else :
+ self.tree.connect(self.ViewElt,SIGNAL("triggered()"),self.view3D)
self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
self.menu.addAction(self.ViewElt)
if self.item.isvalid() :
diff --git a/InterfaceQT4/compooper.py b/InterfaceQT4/compooper.py
index fb3020de..9978be11 100644
--- a/InterfaceQT4/compooper.py
+++ b/InterfaceQT4/compooper.py
@@ -19,9 +19,15 @@
#
import os
import tempfile
-from PyQt4.QtGui import QMessageBox, QAction, QApplication, QCursor
-from PyQt4.QtGui import *
-from PyQt4.QtCore import Qt, SIGNAL, QVariant
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QMessageBox, QAction, QApplication
+ from PyQt5.QtGui import QCursor
+ from PyQt5.QtCore import Qt
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
@@ -74,7 +80,8 @@ class Node(browser.JDCNode, typeNode.PopUpMenuNode):
self.ViewElt.setEnabled(0)
if self.item.get_nom() == "DISTRIBUTION" :
self.Graphe = QAction(tr('Graphique'),self.tree)
- self.tree.connect(self.Graphe,SIGNAL("triggered()"),self.viewPng)
+ if monEnvQT5 : self.Graphe.triggered.connect(self.viewPng)
+ else : self.tree.connect(self.Graphe,SIGNAL("triggered()"),self.viewPng)
self.Graphe.setStatusTip(tr("affiche la distribution "))
self.menu.addAction(self.Graphe)
if self.item.isvalid() :
diff --git a/InterfaceQT4/configuration.py b/InterfaceQT4/configuration.py
index db417830..97b46c0d 100644
--- a/InterfaceQT4/configuration.py
+++ b/InterfaceQT4/configuration.py
@@ -23,7 +23,11 @@
# Modules Python
import os, sys, string, types, re
import traceback
-from PyQt4.QtGui import QMessageBox
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QMessageBox
+else :
+ from PyQt4.QtGui import QMessageBox
from Editeur.utils import read_file
from Extensions.i18n import tr
diff --git a/InterfaceQT4/determine.py b/InterfaceQT4/determine.py
new file mode 100644
index 00000000..f115eae5
--- /dev/null
+++ b/InterfaceQT4/determine.py
@@ -0,0 +1,23 @@
+import os
+
+class envQT(object):
+ _instance = None
+ def __new__(cls, *args, **kwargs):
+ if not cls._instance:
+ cls._instance = super(envQT, cls).__new__(
+ cls, *args, **kwargs)
+
+ return cls._instance
+
+ def __init__(self):
+ if hasattr(self,'inQt5') : return
+ if 'PYQT_ROOT_DIR' in os.environ.keys(): qt=os.environ['PYQT_ROOT_DIR']
+ else : qt="Pyqt4"
+ if 'Pyqt-5' in qt : self.inQt5=True
+ else : self.inQt5=False
+
+
+monEnvQT5=envQT().inQt5
+if __name__=='__main__':
+ inQt5_1=envQT().inQt5
+ inQt5_2=envQT().inQt5
diff --git a/InterfaceQT4/editor.py b/InterfaceQT4/editor.py
index 6562ba77..076c60a2 100755
--- a/InterfaceQT4/editor.py
+++ b/InterfaceQT4/editor.py
@@ -20,9 +20,15 @@
import types,sys,os, re
import subprocess
import traceback
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication
+ from PyQt5.QtGui import QPalette
+ from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
import time
import pdb
from datetime import date
@@ -37,7 +43,6 @@ from Editeur import comploader
from Editeur import Objecttreeitem
from desBaseWidget import Ui_baseWidget
from monViewTexte import ViewText
-from monViewTexte import ViewText2
from monWidgetCreeParam import MonWidgetCreeParam
import browser
import readercata
@@ -46,7 +51,7 @@ DictExtensions= {"MAP" : ".map"}
-class JDCEditor(Ui_baseWidget,QtGui.QWidget):
+class JDCEditor(Ui_baseWidget,QWidget):
# ----------------------------------------- #
"""
Editeur de jdc
@@ -55,7 +60,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
#----------------------------------------------------------------------------------------------------------#
- QtGui.QWidget.__init__(self,None)
+ QWidget.__init__(self,None)
self.setupUi(self)
self.widgetOptionnel=None
self.fenetreCentraleAffichee=None
@@ -194,7 +199,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
txt_exception = self.jdc.cr.get_mess_exception()
if txt_exception:
self.jdc = None
- qApp.restoreOverrideCursor()
+ QApplication.restoreOverrideCursor()
self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
else:
@@ -397,8 +402,12 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
f=open(nomFichier,'w')
f.write(txt)
f.close()
- self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
- self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
+ if monEnvQT5 :
+ self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
+ self.monExe.readyReadStandardError.connect( self.readFromStdErr)
+ else :
+ self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
+ self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
exe='sh ' + nomFichier
self.monExe.start(exe)
self.monExe.closeWriteChannel()
@@ -409,12 +418,19 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
except :
pass
-
def readFromStdErr(self):
+ a=self.monExe.readAllStandardError()
+ self.w.view.append(str(a.data(),len(a)))
+
+ def readFromStdErr(self) :
+ a=self.monExe.readAllStandardOutput()
+ self.w.view.append(str(a.data(),len(a)))
+
+ def readFromStdErrQT4(self):
a=self.monExe.readAllStandardError()
self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
- def readFromStdOut(self) :
+ def readFromStdOutQT4(self) :
a=self.monExe.readAllStandardOutput()
self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
@@ -469,10 +485,9 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
#----------------------------------------------#
if self.sb:
mapalette=self.sb.palette()
- from PyQt4.QtGui import QPalette
mapalette.setColor( QPalette.WindowText, couleur )
self.sb.setPalette( mapalette );
- self.sb.showMessage(QString.fromUtf8(message),4000)
+ self.sb.showMessage(message,4000)
self.couleur=couleur
#------------------------------#
@@ -753,7 +768,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
self.appliEficas.CONFIGURATION.savedir,
- self.appliEficas.trUtf8('Wrapper Files (*.xml);;''All Files (*)'))
+ tr('Wrapper Files (*.xml);;''All Files (*)'))
return fichier
#--------------------------------------------------#
@@ -762,7 +777,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
"""
Public slot to write the text to a file.
- @param fn filename to write to (string or QString)
+ @param fn filename to write to string
@return flag indicating success
"""
@@ -785,9 +800,8 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
f.close()
return 1
except IOError, why:
- QMessageBox.critical(self, self.trUtf8('Save File'),
- self.trUtf8('The file %1 could not be saved.
Reason: %2')
- .arg(unicode(fn)).arg(str(why)))
+ QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
+ tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
return 0
#-----------------------------------------------------------#
@@ -928,9 +942,9 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
#-----------------------------------------------------#
if DictExtensions.has_key(self.appli.code) :
chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
- extensions= self.trUtf8(chaine1+ "All Files (*)")
+ extensions= tr(chaine1+ "All Files (*)")
else :
- extensions= self.trUtf8("JDC (*.comm);;" "All Files (*)")
+ extensions= tr("JDC (*.comm);;" "All Files (*)")
if self.appli.code == "MAP" :
extensions = extensions + ";; Run (*.input);;"
@@ -940,6 +954,9 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
extensions,None,
QFileDialog.DontConfirmOverwrite)
if fn.isNull(): return (0, None)
+ if fn == None : return (0, None)
+ if monEnvQT5 : fn=fn[0]
+
ext = QFileInfo(fn).suffix()
if ext.isEmpty(): fn.append(extension)
@@ -948,7 +965,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
tr("Sauvegarde du Fichier"),
tr("Le fichier %s existe deja.",str(fn)),
tr("&Ecraser"),
- self.trUtf8("&Abandonner"))
+ tr("&Abandonner"))
if abort == 1 : return (0, "")
return (1,fn)
@@ -989,15 +1006,19 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
for b in c.children():
if isinstance(b,QPushButton):
avant=b.text()
- if avant.toLatin1()=="&Open":
- b.setText("Save")
- mesFiltres=QStringList()
- mesFiltres << "input Map (*.input)" << "All Files (*)"
+ if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
+ if monEnvQT5 and avant=="&Open": b.setText("Save")
+ if monEnvQT5 :
+ mesFiltres= "input Map (*.input);;All Files (*)"
+ else :
+ mesFiltres=QStringList()
+ mesFiltres << "input Map (*.input)" << "All Files (*)"
monDialog.setNameFilters(mesFiltres)
if monNomFichier!="" : monDialog.selectFile(monNomFichier)
BOk=monDialog.exec_()
if BOk==0: return
- fn=str(monDialog.selectedFiles()[0].toLatin1())
+ if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
+ else : fn=str(monDialog.selectedFiles()[0].toLatin1())
if fn == "" or fn == None : return
if not fn.endswith(".input"):
fn += ".input"
@@ -1185,14 +1206,15 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
- QMessageBox.information( self, titre,QString.fromUtf8(texte))
+ QMessageBox.information( self, titre,texte)
fn = QFileDialog.getOpenFileName(self.appliEficas,
titre,
self.appliEficas.CONFIGURATION.savedir)
- if fn.isNull():
# ce retour est impose par le get_file d'I_JDC
- return None," "
+ if fn.isNull(): return None," "
+ if not fn : return (0, " ")
+ if monEnvQT5 : fn=fn[0]
ulfile = os.path.abspath(unicode(fn))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
@@ -1320,7 +1342,8 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
caption='Fichier Med',
filter=extensions)
- self.fichierMED=str(QSfichier.toLatin1())
+ if monEnvQT5 : QSfichier=QSfichier[0]
+ self.fichierMED=QSfichier
from acquiertGroupes import getGroupes
erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
if erreur != "" : print "a traiter"
@@ -1349,7 +1372,7 @@ class JDCEditor(Ui_baseWidget,QtGui.QWidget):
#---------------------------#
QSfichier=self.openfile.selectedFiles()[0]
- self.fichierMED=str(QSfichier.toLatin1())
+ self.fichierMED=str(QSfichier)
from acquiertGroupes import getGroupes
erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
if erreur != "" : print "a traiter"
diff --git a/InterfaceQT4/eficas_go.py b/InterfaceQT4/eficas_go.py
index a4a05b35..3416834e 100644
--- a/InterfaceQT4/eficas_go.py
+++ b/InterfaceQT4/eficas_go.py
@@ -22,14 +22,19 @@
# Modules Python
import sys,os
repIni=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),".."))
-ihmQTDir=os.path.join(repIni,"UiQT4")
+from determine import monEnvQT5
+if monEnvQT5 :
+ ihmQTDir=os.path.join(repIni,"UiQT5")
+ from PyQt5.QtWidgets import QApplication
+else :
+ ihmQTDir=os.path.join(repIni,"UiQT4")
+ from PyQt4.QtGui import QApplication
editeurDir=os.path.join(repIni,"Editeur")
ihmDir=os.path.join(repIni,"InterfaceQT4")
if ihmDir not in sys.path : sys.path.append(ihmDir)
if ihmQTDir not in sys.path : sys.path.append(ihmQTDir)
if editeurDir not in sys.path :sys.path.append(editeurDir)
-from PyQt4.QtGui import *
def lance_eficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
"""
diff --git a/InterfaceQT4/feuille.py b/InterfaceQT4/feuille.py
index 53e928e1..d314472a 100644
--- a/InterfaceQT4/feuille.py
+++ b/InterfaceQT4/feuille.py
@@ -21,11 +21,16 @@
import string,types,os
import traceback
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QToolButton ,QWidget
+ from PyQt5.QtGui import QFont, QFontMetrics
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
from Extensions.i18n import tr
+
from gereIcones import ContientIcones
from gereIcones import FacultatifOuOptionnel
from qtSaisie import SaisieValeur
@@ -123,7 +128,7 @@ class Feuille(QWidget,ContientIcones,SaisieValeur,FacultatifOuOptionnel):
else :
commentaire=tr("Entrez entre ")+str(mc.min)+(" et ")+str(mc.max) +" " +tr(d_aides[type])+'\n'
aideval=self.node.item.aide()
- commentaire=commentaire + QString.toUtf8(QString(aideval))
+ commentaire=commentaire + tr(aideval)
self.monCommentaireLabel.setText(str(commentaire))
return str(commentaire)
diff --git a/InterfaceQT4/gereIcones.py b/InterfaceQT4/gereIcones.py
index 590763b6..0d1b912a 100644
--- a/InterfaceQT4/gereIcones.py
+++ b/InterfaceQT4/gereIcones.py
@@ -20,10 +20,17 @@
# Modules Python
import string,types,os,re,sys
import traceback
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QMessageBox, QFileDialog
+ from PyQt5.QtGui import QIcon
+ from PyQt5.QtCore import QFileInfo, Qt
+
+else:
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
from Extensions.i18n import tr
listeSuffixe=('bmp','png','jpg' ,'txt','med')
@@ -41,7 +48,8 @@ class FacultatifOuOptionnel:
else :
icon3=QIcon(self.repIcon+"/lettreRblanc30.png")
self.RBRegle.setIcon(icon3)
- self.connect( self.RBRegle,SIGNAL("clicked()"),self.viewRegles)
+ if monEnvQT5 :self.RBRegle.clicked.connect(self.viewRegles)
+ else : self.connect( self.RBRegle,SIGNAL("clicked()"),self.viewRegles)
cle_doc=None
if not hasattr(self,"RBInfo"):return
@@ -54,6 +62,7 @@ class FacultatifOuOptionnel:
else :
self.cle_doc = self.node.item.get_docu()
if self.cle_doc == None : self.RBInfo.close()
+ elif monEnvQT5 : self.RBInfo.clicked.connect (self.viewDoc)
else : self.connect (self.RBInfo,SIGNAL("clicked()"),self.viewDoc)
@@ -90,7 +99,8 @@ class FacultatifOuOptionnel:
return
icon=QIcon(self.repIcon+"/deleteRond.png")
self.RBPoubelle.setIcon(icon)
- self.connect(self.RBPoubelle,SIGNAL("clicked()"),self.aDetruire)
+ if monEnvQT5 : self.RBPoubelle.clicked.connect(self.aDetruire)
+ else : self.connect(self.RBPoubelle,SIGNAL("clicked()"),self.aDetruire)
def setIconesSalome(self):
if not (hasattr(self,"RBSalome")): return
@@ -104,7 +114,8 @@ class FacultatifOuOptionnel:
if enable_salome_selection:
icon=QIcon(self.repIcon+"/flecheSalome.png")
self.RBSalome.setIcon(icon)
- self.connect(self.RBSalome,SIGNAL("pressed()"),self.BSalomePressed)
+ if monEnvQT5 : self.RBSalome.pressed.connect(self.BSalomePressed)
+ else : self.connect(self.RBSalome,SIGNAL("pressed()"),self.BSalomePressed)
#PNPN --> Telemac A revoir surement
# cela ou le catalogue grpma ou salomeEntry
@@ -113,7 +124,8 @@ class FacultatifOuOptionnel:
else :
icon1=QIcon(self.repIcon+"/eye.png")
self.RBSalomeVue.setIcon(icon1)
- self.connect(self.RBSalomeVue,SIGNAL("clicked()"),self.BView2DPressed)
+ if monEnvQT5 : self.RBSalomeVue.clicked.connect(self.BView2DPressed)
+ else : self.connect(self.RBSalomeVue,SIGNAL("clicked()"),self.BView2DPressed)
else:
self.RBSalome.close()
self.RBSalomeVue.close()
@@ -125,11 +137,14 @@ class FacultatifOuOptionnel:
mctype = mc.type[0]
if mctype == "Repertoire":
self.BRepertoire=self.BFichier
- self.connect(self.BRepertoire,SIGNAL("clicked()"),self.BRepertoirePressed)
+ if monEnvQT5 : self.BRepertoire.clicked.connect(self.BRepertoirePressed)
+ else : self.connect(self.BRepertoire,SIGNAL("clicked()"),self.BRepertoirePressed)
self.BVisuFichier.close()
else :
- self.connect(self.BFichier,SIGNAL("clicked()"),self.BFichierPressed)
- self.connect(self.BVisuFichier,SIGNAL("clicked()"),self.BFichierVisu)
+ if monEnvQT5 : self.BFichier.clicked.connect(self.BFichierPressed)
+ else : self.connect(self.BFichier,SIGNAL("clicked()"),self.BFichierPressed)
+ if monEnvQT5 : self.BVisuFichier.clicked.connect(self.BFichierVisu)
+ else : self.connect(self.BVisuFichier,SIGNAL("clicked()"),self.BFichierVisu)
@@ -219,7 +234,7 @@ class ContientIcones:
elif hasattr(mctype[0], "filters"):
filters = mctype[0].filters
else:
- filters = QString()
+ filters = None
if len(mctype) > 2 and mctype[2] == "Sauvegarde":
fichier = QFileDialog.getSaveFileName(self.appliEficas,
tr('Sauvegarder Fichier'),
@@ -232,6 +247,7 @@ class ContientIcones:
filters)
if not(fichier.isNull()):
+ if monEnvQT5 : fichier=fichier[0]
ulfile = os.path.abspath(unicode(fichier))
self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
self.lineEditVal.setText(fichier)
@@ -245,7 +261,8 @@ class ContientIcones:
self.BSelectInFile.setObjectName("BSelectInFile")
self.gridLayout.addWidget(self.BSelectInFile,1,1,1,1)
self.BSelectInFile.setText(tr("Selection"))
- self.connect(self.BSelectInFile,SIGNAL("clicked()"),self.BSelectInFilePressed)
+ if monEnvQT5 : self.BSelectInFile.clicked.connect(self.BSelectInFilePressed)
+ else : self.connect(self.BSelectInFile,SIGNAL("clicked()"),self.BSelectInFilePressed)
else :
self.BSelectInFile.setVisible(1)
elif hasattr(self, "BSelectInFile"):
@@ -314,8 +331,8 @@ class ContientIcones:
def BView2DPressed(self):
valeur=self.lineEditVal.text()
- if valeur == QString("") : return
valeur = str(valeur)
+ if valeur == str("") : return
if valeur :
ok, msgError = self.appliEficas.displayShape(valeur)
if not ok:
diff --git a/InterfaceQT4/gereListe.py b/InterfaceQT4/gereListe.py
index d8309912..a0426de0 100644
--- a/InterfaceQT4/gereListe.py
+++ b/InterfaceQT4/gereListe.py
@@ -21,9 +21,14 @@
import string,types,os
import traceback
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QLineEdit, QLabel, QIcon
+ from PyQt5.QtCore import QEvent
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
from Extensions.i18n import tr
from monViewTexte import ViewText
@@ -93,15 +98,23 @@ class GereListe:
# ------------- #
def __init__(self):
- self.connecterSignaux()
+ if monEnvQT5 :self.connecterSignaux()
+ else : self.connecterSignauxQT4()
- def connecterSignaux(self):
+ def connecterSignauxQT4(self):
self.connect(self.RBHaut,SIGNAL("clicked()"),self.hautPushed)
self.connect(self.RBBas,SIGNAL("clicked()"),self.basPushed)
self.connect(self.RBMoins,SIGNAL("clicked()"),self.moinsPushed)
self.connect(self.RBPlus,SIGNAL("clicked()"),self.plusPushed)
self.connect(self.RBVoisListe,SIGNAL("clicked()"),self.voisListePushed)
+ def connecterSignaux(self):
+ self.RBHaut.clicked.connect(self.hautPushed)
+ self.RBBas.clicked.connect(self.basPushed)
+ self.RBMoins.clicked.connect(self.moinsPushed)
+ self.RBPlus.clicked.connect(self.plusPushed)
+ self.RBVoisListe.clicked.connect(self.voisListePushed)
+
def hautPushed(self):
if self.NumLineEditEnCours == 1 : return
else : numEchange=self.NumLineEditEnCours-1
@@ -218,7 +231,8 @@ class GerePlie:
fichier=os.path.join(repIcon, 'minusnode.png')
icon = QIcon(fichier)
self.BFermeListe.setIcon(icon)
- self.connect(self.BFermeListe,SIGNAL("clicked()"), self.selectWidgetPlie)
+ if monEnvQT5 : self.BFermeListe.clicked.connect( self.selectWidgetPlie)
+ else : self.connect(self.BFermeListe,SIGNAL("clicked()"), self.selectWidgetPlie)
def selectWidgetPlie(self):
self.editor.listeDesListesOuvertes.remove(self.node.item)
diff --git a/InterfaceQT4/gereRegles.py b/InterfaceQT4/gereRegles.py
index c2923535..0ef22692 100644
--- a/InterfaceQT4/gereRegles.py
+++ b/InterfaceQT4/gereRegles.py
@@ -18,7 +18,11 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtCore import Qt
+else:
+ from PyQt4.QtCore import *
from monViewRegles import ViewRegles
class GereRegles :
diff --git a/InterfaceQT4/gereTraduction.py b/InterfaceQT4/gereTraduction.py
index fce86785..34011519 100644
--- a/InterfaceQT4/gereTraduction.py
+++ b/InterfaceQT4/gereTraduction.py
@@ -16,9 +16,13 @@
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QFileDialog, QApplication
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
import os
from Extensions.i18n import tr
@@ -37,10 +41,11 @@ def traduction(directPath,editor,version):
fn = QFileDialog.getOpenFileName(
editor.appliEficas,
tr('Traduire Fichier'),
- QString(directPath) ,
+ directPath ,
tr('Fichiers JDC (*.comm);;''Tous les Fichiers (*)'))
+ if monEnvQT5 : fn=fn[0]
FichieraTraduire=str(fn)
if (FichieraTraduire == "" or FichieraTraduire == () ) : return
i=FichieraTraduire.rfind(".")
@@ -53,11 +58,11 @@ def traduction(directPath,editor,version):
os.system("rm -rf "+log)
os.system("rm -rf "+FichierTraduit)
- qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
+ QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
if version == "V9V10" : traduitV9V10.traduc(FichieraTraduire,FichierTraduit,log)
if version == "V10V11" : traduitV10V11.traduc(FichieraTraduire,FichierTraduit,log)
if version == "V11V12" : traduitV11V12.traduc(FichieraTraduire,FichierTraduit,log)
- qApp.setOverrideCursor(QCursor(Qt.ArrowCursor))
+ QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))
Entete=tr("Fichier Traduit : %s\n\n",str(FichierTraduit))
if os.stat(log)[6] != 0L :
diff --git a/InterfaceQT4/groupe.py b/InterfaceQT4/groupe.py
index c1eb58ca..86b304ec 100644
--- a/InterfaceQT4/groupe.py
+++ b/InterfaceQT4/groupe.py
@@ -19,9 +19,14 @@
# Modules Python
# Modules Eficas
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QWidget
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+from Extensions.i18n import tr
+
from Extensions.i18n import tr
from gereIcones import FacultatifOuOptionnel
import Accas
@@ -29,11 +34,11 @@ import Accas
# Import des panels
-class Groupe(QtGui.QWidget,FacultatifOuOptionnel):
+class Groupe(QWidget,FacultatifOuOptionnel):
"""
"""
def __init__(self,node,editor,parentQt,definition,obj,niveau,commande=None):
- QtGui.QWidget.__init__(self,None)
+ QWidget.__init__(self,None)
self.node=node
self.node.fenetre=self
#print "groupe : ",self.node.item.nom," ",self.node.fenetre
@@ -57,8 +62,10 @@ class Groupe(QtGui.QWidget,FacultatifOuOptionnel):
self.afficheMots()
self.listeMCAAjouter=[]
self.dictMCVenantDesBlocs={}
- if hasattr(self,'RBDeplie') : self.connect(self.RBDeplie,SIGNAL("clicked()"), self.Deplie)
- if hasattr(self,'RBPlie') : self.connect(self.RBPlie,SIGNAL("clicked()"), self.Plie)
+ if hasattr(self,'RBDeplie') and not monEnvQT5 : self.connect(self.RBDeplie,SIGNAL("clicked()"), self.Deplie)
+ if hasattr(self,'RBPlie') and not monEnvQT5: self.connect(self.RBPlie,SIGNAL("clicked()"), self.Plie)
+ if hasattr(self,'RBDeplie') and monEnvQT5: self.RBDeplie.clicked.connect(self.Deplie)
+ if hasattr(self,'RBPlie') and monEnvQT5: self.RBPlie.clicked.connect( self.Plie)
self.setAcceptDrops(True)
#self.donneFocus()
diff --git a/InterfaceQT4/monBoutonValide.py b/InterfaceQT4/monBoutonValide.py
index 7ae919ff..0027be39 100644
--- a/InterfaceQT4/monBoutonValide.py
+++ b/InterfaceQT4/monBoutonValide.py
@@ -20,8 +20,12 @@
#
import re
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5:
+ from PyQt5.QtWidgets import QToolButton
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
from Extensions.i18n import tr
class MonBoutonValide(QToolButton) :
diff --git a/InterfaceQT4/monChoixCata.py b/InterfaceQT4/monChoixCata.py
index 1a4199a2..7527606f 100644
--- a/InterfaceQT4/monChoixCata.py
+++ b/InterfaceQT4/monChoixCata.py
@@ -21,14 +21,16 @@
# Modules Eficas
from desChoixCata import Ui_DChoixCata
-from PyQt4 import *
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QDialog
+else:
+ from PyQt4.QtGui import *
from Extensions.i18n import tr
# Import des panels
-class MonChoixCata(Ui_DChoixCata,QtGui.QDialog):
+class MonChoixCata(Ui_DChoixCata,QDialog):
"""
Classe définissant le panel associé aux mots-clés qui demandent
à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
diff --git a/InterfaceQT4/monChoixCode.py b/InterfaceQT4/monChoixCode.py
index fcd19856..e362e581 100644
--- a/InterfaceQT4/monChoixCode.py
+++ b/InterfaceQT4/monChoixCode.py
@@ -22,8 +22,13 @@
import os,sys,re
from desChoixCode import Ui_ChoixCode
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+f monEnvQT5:
+ from PyQt5.QtWidgets import QDialog, QRadioButton
+ from PyQt5.QtGui import QPalette
+ from PyQt5.QtCore import QProcess, QFileInfo, Qt
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
# Import des panels
@@ -41,8 +46,12 @@ class MonChoixCode(Ui_ChoixCode,QDialog):
self.parentAppli=parentAppli
self.verifieInstall()
self.code=None
- self.connect(self.pB_OK,SIGNAL("clicked()"),self.choisitCode)
- self.connect(self.pB_cancel,SIGNAL("clicked()"),self.sortie)
+ if monEnvQT5:
+ self.pB_OK.clicked.connect(self.choisitCode)
+ self.pB_cancel.clicked.connect(self.sortie)
+ else :
+ self.connect(self.pB_OK,SIGNAL("clicked()"),self.choisitCode)
+ self.connect(self.pB_cancel,SIGNAL("clicked()"),self.sortie)
def sortie(self):
QDialog.reject(self)
diff --git a/InterfaceQT4/monChoixCommande.py b/InterfaceQT4/monChoixCommande.py
index aa84ce67..a8cc984e 100644
--- a/InterfaceQT4/monChoixCommande.py
+++ b/InterfaceQT4/monChoixCommande.py
@@ -20,28 +20,33 @@
# Modules Eficas
from desChoixCommandes import Ui_ChoixCommandes
-from PyQt4 import *
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from determine import monEnvQT5
+if monEnvQT5 :
+ from PyQt5.QtWidgets import QWidget, QAction ,QButtonGroup, QRadioButton, QLabel
+ from PyQt5.QtGui import QIcon
+ from PyQt5.QtCore import QSize
+else :
+ from PyQt4.QtGui import *
+ from PyQt4.QtCore import *
+
from Extensions.i18n import tr
import os
# Import des panels
-class MonChoixCommande(Ui_ChoixCommandes,QtGui.QWidget):
+class MonChoixCommande(Ui_ChoixCommandes,QWidget):
"""
"""
def __init__(self,node, jdc_item, editor):
- QtGui.QWidget.__init__(self,None)
+ QWidget.__init__(self,None)
self.setupUi(self)
self.repIcon=os.path.join( os.path.dirname(os.path.abspath(__file__)),'..','Editeur','icons')
iconeFile=os.path.join(self.repIcon,'lettreRblanc30.png')
icon = QIcon(iconeFile)
self.RBRegle.setIcon(icon)
- self.RBRegle.setIconSize(QtCore.QSize(21, 31))
+ self.RBRegle.setIconSize(QSize(21, 31))
self.item = jdc_item
self.node = node
@@ -58,15 +63,26 @@ class MonChoixCommande(Ui_ChoixCommandes,QtGui.QWidget):
#print self.node.tree
- self.connect(self.RBalpha,SIGNAL("clicked()"),self.afficheAlpha)
- self.connect(self.RBGroupe,SIGNAL("clicked()"),self.afficheGroupe)
- self.connect(self.RBOrdre,SIGNAL("clicked()"),self.afficheOrdre)
- self.connect(self.RBClear,SIGNAL("clicked()"),self.clearFiltre)
- self.connect(self.RBCasse,SIGNAL("toggled(bool)"),self.ajouteRadioButtons)
+ if monEnvQT5 :
+ self.RBalpha.clicked.connect(self.afficheAlpha)
+ self.RBGroupe.clicked.connect(self.afficheGroupe)
+ self.RBOrdre.clicked.connect(self.afficheOrdre)
+ self.RBClear.clicked.connect(self.clearFiltre)
+ self.RBCasse.toggled.connect(self.ajouteRadioButtons)
+ self.LEFiltre.returnPressed.connect(self.ajouteRadioButtons)
+ else :
+ self.connect(self.RBalpha,SIGNAL("clicked()"),self.afficheAlpha)
+ self.connect(self.RBGroupe,SIGNAL("clicked()"),self.afficheGroupe)
+ self.connect(self.RBOrdre,SIGNAL("clicked()"),self.afficheOrdre)
+ self.connect(self.RBClear,SIGNAL("clicked()"),self.clearFiltre)
+ self.connect(self.RBCasse,SIGNAL("toggled(bool)"),self.ajouteRadioButtons)
+ self.connect(self.LEFiltre,SIGNAL("returnPressed()"),self.ajouteRadioButtons)
if self.node.tree.item.get_regles() == () :
self.RBRegle.close()
self.labelRegle.close()
- else : self.connect(self.RBRegle,SIGNAL("clicked()"),self.afficheRegle)
+ else :
+ if monEnvQT5 : self.RBRegle.clicked.connect(self.afficheRegle)
+ else : self.connect(self.RBRegle,SIGNAL("clicked()"),self.afficheRegle)
if self.editor.Ordre_Des_Commandes == None : self.RBOrdre.close()
@@ -76,7 +92,6 @@ class MonChoixCommande(Ui_ChoixCommandes,QtGui.QWidget):
self.editor.widgetOptionnel.close()
self.editor.widgetOptionnel=None
self.name=None
- self.connect(self.LEFiltre,SIGNAL("returnPressed()"),self.ajouteRadioButtons)
self.affiche_alpha=0
self.affiche_groupe=0
@@ -176,13 +191,19 @@ class MonChoixCommande(Ui_ChoixCommandes,QtGui.QWidget):
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
rbcmd.mouseDoubleClickEvent=self.mouseDoubleClickEvent
- self.connect(self.buttonGroup, SIGNAL("buttonClicked(QAbstractButton*)"),self.rbClique)
+ if monEnvQT5:
+ self.buttonGroup.buttonClicked.connect(self.rbClique)
+ else :
+ self.connect(self.buttonGroup, SIGNAL("buttonClicked(QAbstractButton*)"),self.rbClique)
elif self.affiche_groupe==1 :
listeGroupes,dictGroupes=self.jdc.get_groups()
for grp in listeGroupes:
if grp == "CACHE" : continue
label=QLabel(self)
- text=QString.fromUtf8('Groupe : '+tr(grp)+'
')
+ if monEnvQT5 :
+ text=tr('