Discussion :

[IPreferCSharp]

Salut à tous !

Je suis en train de dev un petit logiciel en python + PySide,
Voici un screen de manière à illustrer mes propos



Voici mon interface actuelle.

Afin de répondre au besoin utilisateur je doit avoir une interface du type :


Mon problème est le suivant, afin de m'éviter du code (surtout du code pas propre), j'aimerais essayer de gérer mes composants de manière à ne pas faire une méthode pour chacun

Aujourd'hui mon code pour remplir mes elements est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def set_combobox_db(self):
        """
        Method to set elements into the combobox db
        """
        try:
            process_db = processing_db_access_conf()
            path_file = process_db.get_one_conf_path()
            c_process = Processing(path_file)
 
            bases = c_process.get_all_db()
            self.comboBox.clear()
            for base in bases:
                self.comboBox.addItem(base)
        except:
            pass
 
    def set_combobox_element(self):
        """
        Method to set elements into the combobox element
        """
        try:
            process_db = processing_db_access_conf()
            path_file = process_db.get_one_conf_path()
            c_process = Processing(path_file)
 
            get_text_cb_db = str(self.comboBox.currentText())
            bases = c_process.get_data_all(get_text_cb_db)
            self.comboBox_2.clear()
            for base in bases:
                self.comboBox_2.addItem(base)
        except:
            pass

j'aimerais faire en sorte de ne pas avoir une méthode pour chaque composant.

idem pour ma méthode d'envoi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 def cmd_set(self):
         #run the timer
        self.create_timer()
 
        #Connect the signal
        self.connect_signal()
        #Run the thread
        self.com_monitor_thread.start()
 
        process_db = processing_db_access_conf()
        path_file = process_db.get_one_conf_path()
        c_processing = Processing(path_file)
        list_to_prepare =[]
 
        text_db = self.comboBox.currentText()
        text_element = self.comboBox_2.currentText()
        text_value = self.lineEdit.text()
 
        value_to_send = c_processing.get_values(text_value)
 
        list_cmd = ['DRV_COM_COMMANDS','CMD_SET']
 
        #get the encoded data
        data = self.get_data_to_send(list_cmd)
 
        list_without_lenght = [data[0],data[1],data[2],value_to_send[0],value_to_send[1]]
 
 
        c_processing_json_file = processing_db_access_conf()
        data_json = c_processing_json_file.open_json_file_read()
        com_port =data_json["com"]["port_com"]
 
        self.connection.connect(com_port)
 
        #Check if thread is ready to read the serial port
        self.is_ready_to_read()
 
        #Send data
        self.connection.send_message(list_without_lenght)
        self.connection.close_connection()

Quelqu'un a t'il une méthode a me conseiller ?
J'ai essayer de chercher mais je n'arrive pas a formuler ma recherche correctement

Merci d'avance

[VinsS]

Salut,

Tu sous-classes tes comboBox et tu y intègres les méthodes en question.

Si j'ai bien compris ta question.

[IPreferCSharp]

Bonjour,

Merci de ta réponse, je sais pas, je ne comprend pas tout a fait ta réponse, qu'entend tu par sous-classer ?

[wiztricks]

Salut,

Pas facile de traiter des questions de "design" comme çà.

Regardez les deux premières méthodes: set_combobox_[db|element].
Elles récupèrent une liste de labels dans le fichier de configuration pour en faire les items qui iront s'afficher dans les combobox associées.
Ca tire des informations d'un truc pour les pousser dans un autre.

Intuitivement tirer/pousser c'est deux lignes pas 10.
On pourrait écrire çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
   def set_combobox_db(self):
            """
            Method to set elements into the combobox db
            """
            try:
                labels = self.c_process.get_all_db()
                self.comboBox.set_items(labels)
#                 process_db = processing_db_access_conf()
#                 path_file = process_db.get_one_conf_path()
#                 c_process = Processing(path_file)
#      
#                 bases = c_process.get_all_db()
#                 self.comboBox.clear()
#                 for base in bases:
#                     self.comboBox.addItem(base)
            except:
                pass
 
        def set_combobox_element(self):
            """
            Method to set elements into the combobox element
            """
            try:
                labels = self.c_process.get_data_all()
                self.comboBox2.set_items(labels)
#                process_db = processing_db_access_conf()
#                 path_file = process_db.get_one_conf_path()
#                 c_process = Processing(path_file)
#      
#                 get_text_cb_db = str(self.comboBox.currentText())
#                 bases = c_process.get_data_all(get_text_cb_db)
#                 self.comboBox_2.clear()
#                 for base in bases:
#                     self.comboBox_2.addItem(base)
            except:
                pass

Au delà de l'aspect "factorisation", il y a un aspect attribution de rôle et responsabilité a combobox: set_items et à c_process: get_all_db, get_data_all.
Côté Combobox, effectivement comme le suggère VinS, on peut sous-classer pour y ajouter set_items

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class MyCombobox(...):
    def set_items(self, labels):
            self.clear()
            for s in labels:
                self.addItem(s)

Côté c_process, on pourrait avoir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class CProcess:
    def __init__(self):
        process_db = processing_db_access_conf()
        path_file = process_db.get_one_conf_path()
        self.handle = Processing(path_file)
 
    def get_all_db(self):
        return self.handle.get_all_db()
 
    def get_data_all(self, name):
        return self.handle.get_data_all(name)

et un truc Python qui s'appelle property pour faire un peu magique (dans la classe appelante):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
    _c_process = None
    @property    
    def c_process(self):
        if self._c_process is None:
            self._c_process = CProcess()
        return self._c_process

Pour revenir à la question:

Mon problème est le suivant, afin de m'éviter du code (surtout du code pas propre), j'aimerais essayer de gérer mes composants de manière à ne pas faire une méthode pour chacun

Ici on fait de l'informatique, i.e. de la mise en forme des informations...
Ces informations sont tirées de A et poussées dans B par vos méthodes qui ont un rôle de médiation entre les deux.
On a une sorte de flux: A -> M -> B
Le but du jeu sera de pousser dans des méthodes de A et de B tout ce qui pourra simplifier le boulot de M

Voilà le concept, mais c'est plus facile à dessiner qu'a raconter.

- W

[IPreferCSharp]

Merci pour ces réponses, je vais essayer d'implanter ça aujourd'hui


Edit : C'est good j'ai réussi a faire ce que je voulais, par contre j'ai utiliser les QSignalMapper http://qt-project.org/doc/qt-4.8/qsignalmapper.html, ça marche très bien .