IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Matrice de transitions


Sujet :

C++

  1. #1
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut Matrice de transitions
    Je travaille avec C++ Builder Xe , donc un compilateur C++03 pas trop standard avec des extensions: enum typés, et pleins de mots clef pour l'IDE/ la bibliothèque VCL
    Et par exemple Boost ne compile pas toujours.

    J'ai une IHM avec un menu à gauche avec 6 entrées

    Lorsque je clique sur une entrée, un écran/ contrôleur s'affiche sur les 6/ 10ième droit.
    Donc à partir d'un écran, j'ai accès aux 5 autres écrans: soit une matrice de transitions (ce n'est pas terrible comme terme )

    Donc le code est le suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
      current_controller->set_parent(NULL);
      je déselectionne l'entrée courante
     
      new_controller->set_parent(&main_form);
      je sélectionne la nouvelle entrée
     
      current_controller = new_controller // <- actuellement c'est avec un état enum
    Mais, parce que sinon c'est trop facile :
    1) Sur l'écran 1 et l'écran 3, j'ai une liste de XXX que je partage entre les 2 écrans

    Si (current_controller != 1) && (current_controller != 3) && ((new_controller == 3) || (new_controller == 1)) -> j'affiche la liste
    Si (current_controller == 1) && (new_controller == 3) -> je repositionne la liste et je sélectionne la première ligne
    Si (current_controller == 3) && (new_controller == 1) -> je repositionne la liste et je sélectionne la première ligne

    Mais il faut aussi penser à la cacher

    Si ((current_controller == 1) || (current_controller == 3)) && (new_controller != 3) && (new_controller != 1) -> je cache la liste

    2) l'écran 6 est l'écran de "settings" (langue et couleur)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
      Si (current_controller == 6)
      alors
         controller_06->set_parent(NULL);
         je déselectionne l'entrée 06
     
         je sélectionne la nouvelle entrée
     
         si (il n'y a pas de changements) -> j'affiche le nouvel écran
         sinon -> je lance un thread pour répercuter les changements partout, et écrire le fichier de configuration
      fsi
    3) Extra : on voit clairement que 1 entrée (un label texte) est associée à un contrôleur (mais dans mon code je n'ai pas créé de classe d'association)
    Sauf pour l'écran 4 , où l'entrée est sur 2 labels


    J'ai codé cela avec 6 switch cases de 6 cas (avec le cas diagonal vide à chaque fois) : cela fonctionne parfaitement.


    Mais j'ai un autre menu ... un menu à 33 entrées (soit 33*32 cas = 1056) : avec 33 switch cases de 32 cas + 1 cas diagonal vide (7000 - 8000 lignes le machin )
    cela pique fortement
    Et là je vais avoir 3 à 5 listes partagées, et sûrement des tests réseau "au début"


    Est-ce que vous avez une idée de coder un truc dynamique avec des pointeurs de fonctions/ méthodes, machines à états, ... ?


    En gros, mon code: j'ai une classe "groupe de contrôleurs" qui contiennent tous les contrôleurs (6 ou 33) et c'est ce groupe qui fait l'affichage du menu.

    [Et actuellement, je n'ai pas d'héritage, pas de virtuel, pas de pointeurs, juste un état enum de 6 ou 33 valeurs: de la composition la plus simple ]
    [au début, j'avais séparé ce groupe et le menu, mais pour plus de facilité, j'ai fusionné les 2 classes]

  2. #2
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    En premiere idée, je dirai une map (ou autre) d'enum vers pointeurs de fonctions

    En mieux, il y a boost::function.
    S'il ne compile pas, tu dois pouvoir la reconstruire, mais tu va galérer quelque peu.

  3. #3
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    760
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 760
    Par défaut
    Je ferrais probablement cela à gros coup de template. Même si j'ai l'impression qu'à part les cas 1/3, 4 et 6, le code est toujours identique, non ?

    C'est possible de voir le switch 6*6 pour se faire une meilleure idée de la forme du code ?

  4. #4
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut
    Citation Envoyé par jo_link_noir Voir le message
    C'est possible de voir le switch 6*6 pour se faire une meilleure idée de la forme du code ?


    L'écran 1 -> STATE_SITE_LOG_IN
    L'écran 3 -> STATE_SITE_DELETE
    L'écran 6 -> STATE_SETTINGS_CHANGE

    le booléen bypass_test sert à désactiver le test puisqu'une fois le thread fini, on relance l'évènement (c'est une sécurité de ne pas avoir une boucle infinie impromptue)

    select_admin_change_pwd et STATE_ADMIN_CHANGE_PWD doivent gérer une entrée sur 2 labels (mais ce sera sûrement la seule entrée comme cela du logiciel)

    Tous les switch ont leurs case dans l'ordre et sans trou pour [plus ou moins] forcer le compilateur à créer des jump tables
    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    void __fastcall Group_Login::select_admin_change_pwd(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		frame_admin_log_out.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_log_out, &select_admin_log_out)
     
    		DISPLAY_SCREEN_ADMIN_CHANGE_PWD
    		break;
     
    	case STATE_SITE_CREATE:
    		frame_site_create.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_create, &select_site_create)
     
    		DISPLAY_SCREEN_ADMIN_CHANGE_PWD
    		break;
     
    	case STATE_SITE_DELETE:
    		frame_site_delete.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_delete, &select_site_delete)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN_ADMIN_CHANGE_PWD
    		break;
     
    	case STATE_SITE_LOG_IN:
    		frame_site_log_in.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_log_in, &select_site_log_in)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN_ADMIN_CHANGE_PWD
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		frame_settings_change.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_settings_change, &select_settings_change)
     
    		b_lang_has_changed  = (lang  != IHM_GET_LANG());
    		b_theme_has_changed = (theme != bundle.current_theme);
     
    		if (bypass_test || (!b_lang_has_changed && !b_theme_has_changed)) {
    			DISPLAY_SCREEN_ADMIN_CHANGE_PWD
    		} else {
    			SELECT_MENU(label_admin_change_pwd1)
    			SELECT_MENU(label_admin_change_pwd2)
    			LAUNCH_WAIT_SETTING_CHANGE(&Group_Login::select_admin_change_pwd)
    		}
    		break;
    	}
    }
     
     
    void __fastcall Group_Login::select_admin_log_out(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		frame_admin_change_pwd.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_change_pwd1, &select_admin_change_pwd)
    		UNSELECT_MENU(label_admin_change_pwd2, &select_admin_change_pwd)
     
    		DISPLAY_SCREEN(frame_admin_log_out)
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		break;
     
    	case STATE_SITE_CREATE:
    		frame_site_create.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_create, &select_site_create)
     
    		DISPLAY_SCREEN(frame_admin_log_out)
    		break;
     
    	case STATE_SITE_DELETE:
    		frame_site_delete.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_delete, &select_site_delete)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_admin_log_out)
    		break;
     
    	case STATE_SITE_LOG_IN:
    		frame_site_log_in.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_log_in, &select_site_log_in)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_admin_log_out)
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		frame_settings_change.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_settings_change, &select_settings_change)
     
    		b_lang_has_changed  = (lang  != IHM_GET_LANG());
    		b_theme_has_changed = (theme != bundle.current_theme);
     
    		if (bypass_test || (!b_lang_has_changed && !b_theme_has_changed)) {
    			DISPLAY_SCREEN(frame_admin_log_out)
    		} else {
    			SELECT_CLICKED_MENU()
    			LAUNCH_WAIT_SETTING_CHANGE(&Group_Login::select_admin_log_out)
    		}
    		break;
    	}
    }
     
     
    void __fastcall Group_Login::select_site_create(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		frame_admin_change_pwd.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_change_pwd1, &select_admin_change_pwd)
    		UNSELECT_MENU(label_admin_change_pwd2, &select_admin_change_pwd)
     
    		DISPLAY_SCREEN(frame_site_create)
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		frame_admin_log_out.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_log_out, &select_admin_log_out)
     
    		DISPLAY_SCREEN(frame_site_create)
    		break;
     
    	case STATE_SITE_CREATE:
    		break;
     
    	case STATE_SITE_DELETE:
    		frame_site_delete.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_delete, &select_site_delete)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_site_create)
    		break;
     
    	case STATE_SITE_LOG_IN:
    		frame_site_log_in.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_log_in, &select_site_log_in)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_site_create)
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		frame_settings_change.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_settings_change, &select_settings_change)
     
    		b_lang_has_changed  = (lang  != IHM_GET_LANG());
    		b_theme_has_changed = (theme != bundle.current_theme);
     
    		if (bypass_test || (!b_lang_has_changed && !b_theme_has_changed)) {
    			DISPLAY_SCREEN(frame_site_create)
    		} else {
    			SELECT_CLICKED_MENU()
    			LAUNCH_WAIT_SETTING_CHANGE(&Group_Login::select_site_create)
    		}
    		break;
    	}
    }
     
     
    void __fastcall Group_Login::select_site_delete(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		frame_admin_change_pwd.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_change_pwd1, &select_admin_change_pwd)
    		UNSELECT_MENU(label_admin_change_pwd2, &select_admin_change_pwd)
     
    		DISPLAY_SCREEN(frame_site_delete)
     
    		DISPLAY_LIST_DELETE
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		frame_admin_log_out.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_log_out, &select_admin_log_out)
     
    		DISPLAY_SCREEN(frame_site_delete)
     
    		DISPLAY_LIST_DELETE
    		break;
     
    	case STATE_SITE_CREATE:
    		frame_site_create.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_create, &select_site_create)
     
    		DISPLAY_SCREEN(frame_site_delete)
     
    		DISPLAY_LIST_DELETE
    		break;
     
    	case STATE_SITE_DELETE:
    		break;
     
    	case STATE_SITE_LOG_IN:
    		frame_site_log_in.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_log_in, &select_site_log_in)
     
    		frame_site_delete.list_set_position(list_sites, main_form_top_offset,
    				(main_form_left_offset + MENU_LEFT_MARGIN + menu_width), area_width);
     
    //		if (node_count_changed) {
    //			list_sites->RootNodeCount = app_data.nb_sites;
    //			node_count_changed = false;
    //		}
     
    //		Select first
    		list_sites->Selected[list_sites->GetFirst()] = true;
    		on_dbl_click(NULL); // <- update selected_site_id
    		list_sites->ScrollIntoView(list_sites->GetFirst(), true);
     
    		DISPLAY_SCREEN(frame_site_delete)
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		frame_settings_change.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_settings_change, &select_settings_change)
     
    		b_lang_has_changed  = (lang  != IHM_GET_LANG());
    		b_theme_has_changed = (theme != bundle.current_theme);
     
    		if (bypass_test || (!b_lang_has_changed && !b_theme_has_changed)) {
    			DISPLAY_SCREEN(frame_site_delete)
    			DISPLAY_LIST_DELETE
    		} else {
    			SELECT_CLICKED_MENU()
    			LAUNCH_WAIT_SETTING_CHANGE(&Group_Login::select_site_delete)
    		}
    		break;
    	}
    }
     
     
    void __fastcall Group_Login::select_site_log_in(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		frame_admin_change_pwd.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_change_pwd1, &select_admin_change_pwd)
    		UNSELECT_MENU(label_admin_change_pwd2, &select_admin_change_pwd)
     
    		DISPLAY_SCREEN(frame_site_log_in)
     
    		DISPLAY_LIST_LOG_IN
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		frame_admin_log_out.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_log_out, &select_admin_log_out)
     
    		DISPLAY_SCREEN(frame_site_log_in)
     
    		DISPLAY_LIST_LOG_IN
    		break;
     
    	case STATE_SITE_CREATE:
    		frame_site_create.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_create, &select_site_create)
     
    		DISPLAY_SCREEN(frame_site_log_in)
     
    		DISPLAY_LIST_LOG_IN
    		break;
     
    	case STATE_SITE_DELETE:
    		frame_site_delete.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_delete, &select_site_delete)
     
    		frame_site_log_in.list_set_position(list_sites, main_form_top_offset,
    					(main_form_left_offset + MENU_LEFT_MARGIN + menu_width), area_width);
     
    //		if (node_count_changed) {
    //			list_sites->RootNodeCount = app_data.nb_sites;
    //			node_count_changed = false;
    //		}
     
    //		Select first
    		list_sites->Selected[list_sites->GetFirst()] = true;
    		on_dbl_click(NULL); // <- update selected_site_id
    		list_sites->ScrollIntoView(list_sites->GetFirst(), true);
     
    		DISPLAY_SCREEN(frame_site_log_in)
    		break;
     
    	case STATE_SITE_LOG_IN:
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		frame_settings_change.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_settings_change, &select_settings_change)
     
    		b_lang_has_changed  = (lang  != IHM_GET_LANG());
    		b_theme_has_changed = (theme != bundle.current_theme);
     
    		if (bypass_test || (!b_lang_has_changed && !b_theme_has_changed)) {
    			DISPLAY_SCREEN(frame_site_log_in)
    			DISPLAY_LIST_LOG_IN
    		} else {
    			SELECT_CLICKED_MENU()
    			LAUNCH_WAIT_SETTING_CHANGE(&Group_Login::select_site_log_in)
    		}
    		break;
    	}
    }
     
     
    void __fastcall Group_Login::select_settings_change(TObject* sender) {
    	clicked_entry = ((Stdctrls::TLabel*) sender);
     
    	switch(state) {
    	case STATE_ADMIN_CHANGE_PWD:
    		frame_admin_change_pwd.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_change_pwd1, &select_admin_change_pwd)
    		UNSELECT_MENU(label_admin_change_pwd2, &select_admin_change_pwd)
     
    		DISPLAY_SCREEN(frame_settings_change)
    		break;
     
    	case STATE_ADMIN_LOG_OUT:
    		frame_admin_log_out.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_admin_log_out, &select_admin_log_out)
     
    		DISPLAY_SCREEN(frame_settings_change)
    		break;
     
    	case STATE_SITE_CREATE:
    		frame_site_create.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_create, &select_site_create)
     
    		DISPLAY_SCREEN(frame_settings_change)
    		break;
     
    	case STATE_SITE_DELETE:
    		frame_site_delete.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_delete, &select_site_delete)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_settings_change)
    		break;
     
    	case STATE_SITE_LOG_IN:
    		frame_site_log_in.set_parent_ui(NULL);
     
    		UNSELECT_MENU(label_site_log_in, &select_site_log_in)
     
    		list_sites->Parent = NULL;
     
    		DISPLAY_SCREEN(frame_settings_change)
    		break;
     
    	case STATE_SETTINGS_CHANGE:
    		break;
    	}
     
    	theme = bundle.current_theme;
    	lang  = IHM_GET_LANG();
     
    	bypass_test = false;
    }

  5. #5
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    760
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 760
    Par défaut
    Avec un tableau tu te prendrais vachement moins la tête, il n'y aurait qu'un seul switch et une condition supplémentaire dans chaque case pour les valeurs en diagonales (si l'extérieur ne le gère pas déjà).
    Il y a la différence entre DISPLAY_SCREEN_ADMIN_CHANGE_PWD et DISPLAY_SCREEN(truc) à prendre en compte aussi, mais j'ai l'impression que le premier est l'équivalent d'un DISPLAY_SCREEN(frame_admin_change_pwd).

    Si un tableau n'est pas possible à cause de type différent pour les variables frame_*, j'utiliserais un tuple (ou des fonctions get(std::integral_constant<le type enum, la valeur de l'enum>{}) pour récupérer la bonne variable membre si on ne veut pas de tuple) et un template du genre:
    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
    template<class... I, F f>
    cswitch(unsigned i, std::index_sequence<I...>, F f) {
      (void)std::initializer_list<int>((void(
        i == I{} ? f(I{}) : void()
      ), 1)...);
    }
     
    using Seq33 = std::make_index_sequence<33>;
    cswitch(idx_current_controller, Seq33{}, [new_controller](auto idx_current_controller){
      /* ici idx_current_controller est un std::integral_constant*/
      if (idx_current_controller == 6) {
        ...
      }
      else if condition 1 et 3 {
        ...
      }
      else {
        cswitch(idx_new_controller, Seq33{}, [idx_current_controller](auto idx_new_controller){
          /* ici idx_new_controller est un std::integral_constant*/
          truc commuin
        });
      }
    })
    À adapter en C++03 en remplaçant initializer_list + seq33 du cswitch par un vrai switch et les lambdas par des structures.

  6. #6
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut
    J'ai rajouté des choses: sur les écrans 2, 3, et 4 j'ai un panel (un cadre) pour afficher des informations: type et taille de saisie, message de suppression qui efface tout, ...

    Et c'est dans le bousin que je parente/ déparente ce panel pour ainsi ne le faire qu'au bon moment - après c'est le contrôleur qui l'affiche ou le cache et le configure.

    Citation Envoyé par jo_link_noir Voir le message
    Il y a la différence entre DISPLAY_SCREEN_ADMIN_CHANGE_PWD et DISPLAY_SCREEN(truc) à prendre en compte aussi, mais j'ai l'impression que le premier est l'équivalent d'un DISPLAY_SCREEN(frame_admin_change_pwd).


    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
    #define DISPLAY_SCREEN(CONTROLLER) \
    	SELECT_CLICKED_MENU() \
    	 \
    	CONTROLLER.will_appear(); \
    	CONTROLLER.set_parent_ui(&main_form); \
    	CONTROLLER.did_appear(); \
    	 \
    	state = (Group_Login::STATE) clicked_entry->Tag;
     
     
    #define DISPLAY_SCREEN_ADMIN_CHANGE_PWD \
    	SELECT_MENU(label_admin_change_pwd1) \
    	SELECT_MENU(label_admin_change_pwd2) \
    	 \
    	frame_admin_change_pwd.will_appear(); \
    	frame_admin_change_pwd.set_parent_ui(&main_form); \
    	frame_admin_change_pwd.did_appear(); \
    	 \
    	state = (Group_Login::STATE) ((Stdctrls::TLabel*) sender)->Tag;

    Citation Envoyé par ternel Voir le message
    En premiere idée, je dirai une map (ou autre) d'enum vers pointeurs de fonctions
    C'est une idée que j'ai eu effectivement. Mais,
    • Le nombre d'évènements va fortement grandir. Ici, j'ai 6 évènements [menu de X entrées -> X évènements fixes]. Mais je dirais 70% des cas parmi 30 sont différents, soit au moins 12-15 évènements.
    • Avec une matrice de 33*33 le bout de code qui va initialiser cette matrice va être tout autant imbuvable. Surtout si tu as 70% des cas qui sont différents


    Citation Envoyé par jo_link_noir Voir le message
    Avec un tableau tu te prendrais vachement moins la tête, il n'y aurait qu'un seul switch et une condition supplémentaire dans chaque case pour les valeurs en diagonales (si l'extérieur ne le gère pas déjà).
    Je vais étudier ton code ... C++14 (je n'ai pas encore l'habitude) ou

    À vue de nez, j'avais déjà fait comme cela avant (avant de fusionner mon groupe et mon menu).
    Mais tu vas avoir plusieurs tests dans tes cas, mais chaque if peut être du code assez long.
    Donc un seul switch cases mais de 1000-2000 lignes.

    Si j'ai fait X switch cases c'est justement pour éviter d'avoir des tests dans les cas (même si ce n'est pas réellement vrai) et ainsi limiter la taille de mes cas: pas plus de 10 lignes (et un commentaire au niveau de chaque cas pour rappeler l'évènement pour le menu à 33 entrées)

  7. #7
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    760
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 760
    Par défaut
    Citation Envoyé par foetus Voir le message
    Si j'ai fait X switch cases c'est justement pour éviter d'avoir des tests dans les cas (même si ce n'est pas réellement vrai) et ainsi limiter la taille de mes cas: pas plus de 10 lignes (et un commentaire au niveau de chaque cas pour rappeler l'évènement pour le menu à 33 entrées)
    Les if dans mon exemple sont déduits à la compilation et éliminés, un if/else pour choisir DISPLAY_SCREEN_ADMIN_CHANGE_PWD ou DISPLAY_SCREEN(truc) serait aussi supprimés. En C++17 je mettrais constexpr if ce qui élimine également certains problèmes de compilation puisque chaque if doit compiler même s'il n'est pas utilisé. Actuellement, pour pallier au problème, je passe par 2 fonctions, une qui prend un std::true_type et l'autre un std::false_type (do_something(std::integral_constant<bool, idx == 3>(), other_params); par exemple).

    Après oui, tout est regroupé au même endroit, mais il n'y a pas besoin de coder tous les cas puisque tous ce qui est commun peut être écrit une fois. S'il y a globalement 4 situations, il n'y a besoin que de 4 blocs de code.

  8. #8
    Membre émérite
    Profil pro
    Inscrit en
    Mai 2006
    Messages
    780
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : Mai 2006
    Messages : 780
    Par défaut
    En fait c'est pas une machine à état que tu veux faire?

  9. #9
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut
    En réalité, c'est une machine à états. Mais
    • d'un état tu peux aller vers tous les autres états. Donc c'est plus simple de penser à une matrice, qu'à un graphe avec toutes les transitions
    • il n'y a pas de contrainte entre les états. C'est pour cela que j'utilise le terme "matrice de transitions". Parce qu'il suffit juste de cacher l'ancien et d'afficher le nouveau. Mais tu as des éléments partagés à cacher/ afficher (des listes, des panels (cadres), ...), tu as des tests "en entrée" pour savoir comment afficher le nouveau (pas dans mon exemple de menu à 6 entrées), et des tests "en sortie" pour répercuter des changements ou faire autre chose.


    Mais quoi qu'il se passe entre, tu cacheras toujours l'ancien et tu afficheras toujours le nouveau

  10. #10
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut
    Je suis en train de travailler sur une version alternative (je mettrai une bafouille plus tard)

    Et je m’aperçois qu'on peut peut-être trouver une solution en pur objet
    J'appelle un évènement, juste un "case" (soit 1 parmi 6*5 ou 1 parmi 33*32)

    Et justement pour le menu 6 entrées, on voit clairement qu'on peut découper tous les évènements en 8 étapes, toujours dans le même ordre, qu'on va faire ou pas:
    • unparent_panel_infos: on le fait ou pas
    • hide_controler: on le fait toujours, mais il y a en 2
    • list_sites: soit on la déparente, soit on la repositionne (2 cas, mais c'est sûrement un appel d'une fonction virtuelle)
    • test_setting_change: soit on le fait ou pas, mais c'est le point le plus difficile parce que le "else" est la dernière étape
    • display_controler: on le fait toujours, mais il y a en 2
    • parent_panel_infos: on le fait ou pas
    • parent_list_sites: on le fait ou pas
    • extra: soit rien, soit on initialise les variables pour le changement de paramètres, soit le "else" du test


    Et donc, si tous les contrôleurs ont une interface commune, on peut envisager un objet Matrix_Transitions (ou Transition_Manager ou ...)
    Il va contenir:
    • La matrice: std::vector, std::map, static array, ... À voir si on crée une classe Transition contenant une liste d'étapes ou pas
    • Sûrement une liste d'entrées: struct s_Entry { STATE, const Controller&, TLabel*, Event* }
    • ...


    Et ainsi avec une interface naïve: Matrix_Transitions::add_transition(STATE /*current*/, STATE /*new*/, STEP)
    Mais on va se retrouver [sûrement] avec un gros bloc d'initialisation

    Mais on peut améliorer cette interface
    • Matrix_Transitions::add_panel_infos_for_screen(STATE)
    • Matrix_Transitions::add_list_for_screen(STATE)
    • Matrix_Transitions::add_test_for_screen(STATE)


    Et c'est cet objet qui va configurer toutes les transitions

    Il y aura juste à trouver les interactions entre cet objet et mon groupe de contrôleurs

  11. #11
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 759
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 759
    Par défaut
    Je mets en résolu

    Bon j'ai mis en place une solution ... que je n'ai pas pu éprouver avec le temps (je ne suis plus sur le projet et je pense que le projet est mort, du moins avec mon départ j'ai tout fait pour ... sans réellement le vouloir)

    Je n'ai pas eu assez de temps pour tester tout un tas de conception et donc j'ai gardé ma conception "groupe de contrôleurs + menu fusionnés (*)" et mes X switch cases de X cas (**).

    * -> J'ai juste fait le truc classique en C++: 1 entête mais plusieurs .cpp pour bien séparer les choses.

    Et le truc que j'ai fait c'est juste une ligne de commande et un fichier .json qui vont me permettre de générer ce bout de code (**)

    1) La commande "matrix -XXX_empty matrix.json", qui est spécifique pour chaque menu, va me générer un fichier .json vide

    2) La commande "matrix -XXX_create input.json output.json" qui est spécifique pour chaque menu, va remplir la matrice de transitions (matrix) avec les informations des sections list_actions, list_steps et list_entries.
    Certaines informations sont en dur (et il faut recompiler la ligne de commande en cas de changement) et d'autres sont laissées libres à l'utilisateur. La séparation en dur/ libre se fait de façon logique et aussi un peu empiriquement

    J'ai repris mon précédent commentaire. Dans ma matrice, pour 1 transition, il y autant d'espaces (colonnes) qu'il y a d'étapes. Et dans la section list_steps les étapes sont par ordre croissant et pour chaque étape, on va avoir plusieurs caractères (1 caractère == 1 action)

    3) La commande "matrix -XXX_write input.json menu_events.cpp" qui va générer le bout de code (**)

    Et 1 fois le bout de code généré, je remplace le fichier .cpp (si je ne l'ai pas fait directement) et je recompile mon projet (c'est assez rapide en théorie puisqu'il ne recompile qu'1 groupe de contrôleurs)

    Il y a des subtilités pour générer avec les bons noms (%header%), certaines entrées sont des images au lieu d'un libellé, et aussi pour les indentations.


    Un fichier vide:
    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    {
      "group_name": "Group_Login",
      "comment_list_entries": "header == NULL -> is a picture, clicked_entry = NULL",
      "list_entries": [
        {"id": "ADCP", "state": "STATE_ADMIN_CHANGE_PWD", "label": "", "controller": "frame_admin_change_pwd", "event": "select_admin_change_pwd", "header": "header_admin"},
        {"id": "ADLO", "state": "STATE_ADMIN_LOG_OUT",    "label": "", "controller": "frame_admin_log_out",    "event": "select_admin_log_out",    "header": "header_admin"},
        {"id": "SEC ", "state": "STATE_SETTINGS_CHANGE",  "label": "", "controller": "frame_settings_change",  "event": "select_settings_change",  "header": "header_settings"},
        {"id": "SIC ", "state": "STATE_SITE_CREATE",      "label": "", "controller": "frame_site_create",      "event": "select_site_create",      "header": "header_site"},
        {"id": "SID ", "state": "STATE_SITE_DELETE",      "label": "", "controller": "frame_site_delete",      "event": "select_site_delete",      "header": "header_site"},
        {"id": "SILO", "state": "STATE_SITE_LOG_IN",      "label": "", "controller": "frame_site_log_in",      "event": "select_site_log_in",      "header": "header_site"},
        {"id": "SIM ", "state": "STATE_SITE_MODIFY",      "label": "", "controller": "frame_site_modify",      "event": "select_site_modify",      "header": "header_site"},
        {"id": "LIE ", "state": "STATE_LIST_EXPORT",      "label": "", "controller": "frame_list_export",      "event": "select_list_export",      "header": ""},
        {"id": "LII ", "state": "STATE_LIST_IMPORT",      "label": "", "controller": "frame_list_import",      "event": "select_list_import",      "header": ""},
        {"id": "SILI", "state": "STATE_SITE_LIST",        "label": "", "controller": "frame_site_list",        "event": "select_site_list",        "header": ""}
      ],
      "comment_transitions": "column header: current state, line header: next state",
      "matrix": [
    "    ;ADCP    ;ADLO    ;SEC     ;SIC     ;SID     ;SILO    ;SIM     ;LIE     ;LII     ;SILI    ;",
    "ADCP;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "ADLO;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SEC ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SIC ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SID ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SILO;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SIM ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "LIE ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "LII ;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;",
    "SILI;        ;        ;        ;        ;        ;        ;        ;        ;        ;        ;"
      ],
      "comment_actions": [
        {"action": "add_panel_infos", "param": "screen_id"},
        {"action": "add_list",        "param": "screen_id", "other": "step_id"}
      ],
      "list_actions": [
      ],
        "list_steps": [
          {"id": "unparent_panel_infos", "list": [
            {"id": " ", "func": ""},
            {"id": "U", "func": "unparent_panel_infos"}
        ]},
          {"id": "hide_controller",      "list": [
            {"id": " ", "func": ""},
            {"id": "*", "func": "hide_controller"},
            {"id": "A", "func": "hide_admin_change_pwd"},
            {"id": "E", "func": "hide_list_export"},
            {"id": "I", "func": "hide_list_import"},
            {"id": "L", "func": "hide_site_list"}
        ]},
          {"id": "list_sites",           "list": [
            {"id": " ", "func": ""},
            {"id": "H", "func": "unparent_list_sites"},
            {"id": "D", "func": "setup_list_delete"},
            {"id": "L", "func": "setup_list_log_in"}
        ]},
          {"id": "test_setting_change",  "list": [
            {"id": " ", "func": ""},
            {"id": "T", "func": "test_setting_change", "increment_indent": true}
        ]},
          {"id": "display_controller",   "list": [
            {"id": " ", "func": ""},
            {"id": "*", "func": "display_controller"},
            {"id": "A", "func": "display_admin_change_pwd"},
            {"id": "E", "func": "display_list_export"},
            {"id": "I", "func": "display_list_import"},
            {"id": "L", "func": "display_site_list"}
        ]},
          {"id": "parent_panel_infos",   "list": [
            {"id": " ", "func": ""},
            {"id": "P", "func": "parent_panel_infos"}
        ]},
          {"id": "parent_list_sites",    "list": [
            {"id": " ", "func": ""},
            {"id": "D", "func": "parent_list_delete"},
            {"id": "L", "func": "parent_list_log_in"}
        ]},
          {"id": "extra",                "list": [
            {"id": " ", "func": ""},
            {"id": "O", "func": "init_setting_change_value"},
            {"id": "E", "func": "test_setting_change_end", "decrement_indent": true},
            {"id": "A", "func": "test_setting_change_end01", "decrement_indent": true},
            {"id": "X", "func": "test_setting_change_end02", "decrement_indent": true},
            {"id": "I", "func": "test_setting_change_end03", "decrement_indent": true},
            {"id": "L", "func": "test_setting_change_end04", "decrement_indent": true}
        ]}
      ],
      "display_admin_change_pwd": [
    "DISPLAY_SCREEN_ADMIN_CHANGE_PWD"
      ],
      "display_controller": [
    "DISPLAY_SCREEN(%Ncontroller%, CONVERT_XGY_TO_YGX(%header%->color))"
      ],
      "display_list_export": [
    "SELECT_IMG_EXPORT(IMG_EXPORT_BLUE)",
    "",
    "group_bundle.frame_list_export.will_appear();",
    "group_bundle.frame_list_export.set_parent_ui(&main_form);",
    "group_bundle.frame_list_export.did_appear(LIST_SITE);",
    "",
    "state = STATE_LIST_EXPORT;"
      ],
      "display_list_import": [
    "SELECT_IMG_IMPORT(IMG_IMPORT_BLUE)",
    "",
    "group_bundle.frame_list_import.will_appear();",
    "group_bundle.frame_list_import.set_parent_ui(&main_form);",
    "group_bundle.frame_list_import.did_appear(LIST_SITE);",
    "",
    "state = STATE_LIST_IMPORT;"
      ],
      "test_setting_change_end": [
    "} else {",
    "\tSELECT_CLICKED_MENU(CONVERT_XGY_TO_YGX(%header%->color))",
    "\tLAUNCH_WAIT_SETTING_CHANGE(&%group_name%::%Nevent%)",
    "}"
     
    // .....
    }

    La matrice remplie:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
      "matrix": [
    "    ;ADCP    ;ADLO    ;SEC     ;SIC     ;SID     ;SILO    ;SIM     ;LIE     ;LII     ;SILI    ;",
    "ADCP;        ; *  AP  ; * TAP A; *  A   ; *H A   ; *H AP  ; *  AP  ; E  AP  ; I  AP  ; L  AP  ;",
    "ADLO;UA  *   ;        ; * T*  E;U*  *   ;U*H *   ; *H *   ; *  *   ; E  *   ; I  *   ; L  *   ;",
    "SEC ;UA  *  O; *  *  O;        ;U*  *  O;U*H *  O; *H *  O; *  *  O; E  *  O; I  *  O; L  *  O;",
    "SIC ; A  *   ; *  *P  ; * T*P E;        ; *H *   ; *H *P  ; *  *P  ; E  *P  ; I  *P  ; L  *P  ;",
    "SID ; A  * D ; *  *PD ; * T*PDE; *  * D ;        ; *D *P  ; *  *PD ; E  *PD ; I  *PD ; L  *PD ;",
    "SILO;UA  * L ; *  * L ; * T* LE;U*  * L ;U*L *   ;        ; *  * L ; E  * L ; I  * L ; L  * L ;",
    "SIM ;UA  *   ; *  *   ; * T*  E;U*  *   ;U*H *   ; *H *   ;        ; E  *   ; I  *   ; L  *   ;",
    "LIE ;UA  E   ; *  E   ; * TE  X;U*  E   ;U*H E   ; *H E   ; *  E   ;        ; I  E   ; L  E   ;",
    "LII ;UA  I   ; *  I   ; * TI  I;U*  I   ;U*H I   ; *H I   ; *  I   ; E  I   ;        ; L  I   ;",
    "SILI;UA  L   ; *  L   ; * TL  L;U*  L   ;U*H L   ; *H L   ; *  L   ; E  L   ; I  L   ;        ;"
      ],

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 0
    Dernier message: 02/10/2014, 18h07
  2. Réponses: 3
    Dernier message: 18/07/2014, 14h22
  3. Réponses: 3
    Dernier message: 29/12/2009, 16h58
  4. Gestion de matrice
    Par bzd dans le forum C
    Réponses: 4
    Dernier message: 12/08/2002, 18h19
  5. Comment définir le type matrice ?
    Par charly dans le forum Langage
    Réponses: 7
    Dernier message: 15/06/2002, 21h01

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo