Utilisation de multiple composants graphiques ayant la même fonction ,PySide

Version imprimable

2 pièce(s) jointe(s)

Salut à tous !

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

Pièce jointe 149258

Voici mon interface actuelle.

Afin de répondre au besoin utilisateur je doit avoir une interface du type :
Pièce jointe 149259

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:

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:

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

20/06/2014, 17h15
VinsS

Salut,

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

Si j'ai bien compris ta question.
20/06/2014, 17h24
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 ?

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:

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:

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:

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:

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:

Citation:

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

23/06/2014, 08h58
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 .