Forum |  HardWare.fr | News | Articles | PC | Prix | S'identifier | S'inscrire | Aide | Shop Recherche
551 connectés 

  FORUM HardWare.fr
  Programmation
  Java

  activer un bouton radio à partir d'un autre bouton radio en java

 

Sujet(s) à lire :
    - Visual C++
 

 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

activer un bouton radio à partir d'un autre bouton radio en java

n°2211137
manel1989
Posté le 20-11-2013 à 21:38:08  profilanswer
 

Salut tout le monde!
 
j'ai dans ma GUI deux bouton radio choco et gecode et en dessous de chacun j'ai 2 boutons radio optimal solution et Feasible solution mon problème réside dans la sélection des boutons. Je m'explique:
 
lorsque je clique sur le bouton radio choco, je veux avoir la solution optimal du  modèle choco donc je clique sur optimal solution mais là le bouton choco sera non sélectoionné alors qu'il le faut etre selectionné, voici un bout de code mais il ne fonctionne pas correctement  :  

Code :
  1. if ( radio1.isSelected())// bouton du modèle choco
  2.  {
  3.   {
  4.  int[] R1=new int[m];
  5.  int[] C1=new int[m];
  6.  int[] B1=new int[m];
  7.  int[] Dr1=new int[n];
  8.  int[] Dc1=new int[n];
  9.  int[] Db1=new int[n];
  10.  for(int i=0;i<n;i++)
  11.  {
  12.   Dr1[i]=Integer.parseInt(Dr.get(i).toString());
  13.   Dc1[i]=Integer.parseInt(Dc.get(i).toString());
  14.   Db1[i]=Integer.parseInt(Db.get(i).toString());
  15.  }
  16.  for(int i=0;i<m;i++)
  17.  {
  18.   R1[i]=Integer.parseInt(R.get(i).toString());
  19.   C1[i]=Integer.parseInt(C.get(i).toString());
  20.   B1[i]=Integer.parseInt(B.get(i).toString());
  21.  }
  22.        MMKP model=new MMKP();
  23.        res= new int[n][m];
  24.        res2= new int[n][m];
  25.        if ( radio3.isSelected())// bouton de la solution optimal du modèle choco
  26.  {
  27.        res=model.find_Optimal_Solution(n, m, R1, C1, B1, Dr1, Dc1, Db1, GainMatrix1);
  28.        for(int i=0;i<n;i++)
  29.        {
  30.         for(int j=0;j<m;j++)
  31.   System.out.print(res[i][j]+" " );
  32.         System.out.println();
  33.  }
  34.  }
  35.        else if ( radio4.isSelected())// bouton de la solution réalisable du modèle choco  
  36.  {
  37.        res2=model.find_realizable_solution(n, m, R1, C1, B1, Dr1, Dc1, Db1);
  38.        System.out.println("///////////////////////////" );
  39.        for(int i=0;i<n;i++)
  40.        {
  41.         for(int j=0;j<m;j++)
  42.   System.out.print(res2[i][j]+" " );
  43.         System.out.println();
  44.  }}
  45.    
  46.  }
  47.   }
  48.  else if ( radio2.isSelected())  // bouton du modèle Gocode
  49.  {
  50.   if( radio5.isSelected())// bouton pour la solution optimal du modèle gecode  
  51.   {
  52.    try {           
  53.              //Appel du programme C++ a partir de Java
  54.              ProcessBuilder pb = new ProcessBuilder("C:\\Users\\abdelhalim\\Desktop\\MMKPcost1.exe" );         
  55.              Process p = pb.start();           
  56.             
  57.             
  58.              //Creation de 2 threads pour lire les flux de sortie et derreur du programme C++
  59.              ExecutorService executor = Executors.newFixedThreadPool(2);
  60.             
  61.              Callable<String> callableFluxSortie = new AfficheurFlux(p.getInputStream());
  62.              Callable<String> callableFluxErreur = new AfficheurFlux(p.getErrorStream());
  63.             
  64.              Future<String> futureSortie = executor.submit(callableFluxSortie);
  65.              Future<String> futureErreur = executor.submit(callableFluxErreur);
  66.              executor.shutdown();
  67.             
  68.              OutputStream stdin = p.getOutputStream();
  69.              BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stdin));
  70.             
  71.              //nb ligne matrice
  72.              writer.write(String.valueOf(m));
  73.              writer.newLine();
  74.             
  75.             
  76.              //nb colonne matrice
  77.              writer.write(String.valueOf(n));
  78.              writer.newLine();
  79.             
  80.              writer.write(String.valueOf(m));
  81.              writer.newLine();
  82.             
  83.             
  84.              //nb colonne matrice
  85.              writer.write(String.valueOf(n));
  86.              writer.newLine();
  87.         
  88.           for(int i=0; i<R.size();i++)
  89.           { 
  90.            writer.write(String.valueOf(R.get(i)));
  91.                writer.newLine();
  92.         
  93.           }
  94.           for(int i=0; i<C.size();i++)
  95.           { 
  96.            writer.write(String.valueOf(C.get(i)));
  97.                writer.newLine();
  98.         
  99.           }
  100.           for(int i=0; i<B.size();i++)
  101.           { 
  102.            writer.write(String.valueOf(B.get(i)));
  103.                writer.newLine();
  104.         
  105.           } for(int i=0; i<Dr.size();i++)
  106.           { 
  107.            writer.write(String.valueOf(Dr.get(i)));
  108.                writer.newLine();
  109.         
  110.           } for(int i=0; i<Dc.size();i++)
  111.           { 
  112.            writer.write(String.valueOf(Dc.get(i)));
  113.                writer.newLine();
  114.         
  115.           }
  116.           for(int i=0; i<Db.size();i++)
  117.           { 
  118.            writer.write(String.valueOf(Db.get(i)));
  119.                writer.newLine();
  120.         
  121.           }
  122.           /*for(int k=0; k<n;k++)
  123.           {
  124.         for(int j=0; j<m;j++)
  125.          writer.write(String.valueOf(GainMatrix[k][j]));
  126.         writer.newLine();
  127.        }*/
  128.           writer.write(String.valueOf(n));
  129.               writer.newLine();
  130.           writer.write(String.valueOf(m));
  131.               writer.newLine();
  132.               writer.write(String.valueOf(m));
  133.               writer.newLine();
  134.               writer.write(String.valueOf(m));
  135.               writer.newLine();
  136.               writer.write(String.valueOf(n));
  137.               writer.newLine();
  138.           writer.write(String.valueOf(m));
  139.               writer.newLine();
  140.               writer.write(String.valueOf(n));
  141.               writer.newLine();
  142.           writer.write(String.valueOf(m));
  143.               writer.newLine();
  144.               writer.write(String.valueOf(n));
  145.               writer.newLine();
  146.           writer.write(String.valueOf(m));
  147.               writer.newLine();
  148.          
  149.              writer.flush();
  150.              writer.close();           
  151.             
  152.             
  153.              //Attente fin du programme C++
  154.              p.waitFor();
  155.             
  156.              try {
  157.                  System.out.println("\nFlux sortie : \n" + futureSortie.get());
  158.                  String resultat= futureSortie.get().toString();
  159.                 
  160.                  // convert String into InputStream
  161.                     InputStream is = new ByteArrayInputStream(resultat.getBytes());
  162.                     // read it with BufferedReader
  163.                     BufferedReader br = new BufferedReader(new InputStreamReader(is));
  164.                     String line;
  165.                     try {
  166.                      int nbLine = n+1;
  167.                      int nbCol = m;
  168.                      int cpt = 0;
  169.                      int[][] mat = new int[nbLine][nbCol];
  170.                      while ((line = br.readLine()) != null) {
  171.                       if(cpt>=nbLine) break;
  172.                              String[] split = line.trim().split("\\s+" );
  173.                       try{
  174.                        for(int i = 0; i<split.length && i<nbCol; i++){
  175.                         mat[cpt][i] = Integer.parseInt(split[i]);
  176.                        }
  177.                                 }
  178.                                 catch(NumberFormatException e){
  179.                                 }
  180.                       cpt++;
  181.                      }
  182.                      System.out.println("Matrice :" );
  183.                      for(int[] rows : mat){
  184.                       for(int cel : rows){
  185.                        System.out.print(cel + " " );
  186.                       }
  187.                       System.out.println();
  188.                      }
  189.                   
  190.                       res1= new int[nbLine-1][nbCol];
  191.                 
  192.                          int nRows = mat.length;
  193.                          int nColumns = mat[0].length;
  194.                     int newTabRow = 0;
  195.                         int newTabCol = 0;
  196.                   int index=0;
  197.                         for(int i = 0 ; i<nRows ; ++i){
  198.                             if(i != index){
  199.                                 for(int j = 0 ; j<nColumns ; ++j){
  200.                                    
  201.                                         res1[newTabRow][newTabCol] = mat[i][j];
  202.                                         ++newTabCol;
  203.                                    
  204.                                 }
  205.                                 ++newTabRow;
  206.                                 newTabCol = 0;
  207.                             }
  208.                         }
  209.                      for(int[] rows : res1){
  210.                             for(int cel : rows){
  211.                             System.out.print(cel + " " );
  212.                           System.out.println();
  213.                             }
  214.                       }
  215.                     } catch (IOException e) {
  216.                      e.printStackTrace();
  217.                     } finally {
  218.                      try {
  219.                       br.close();
  220.                      } catch (IOException e) {
  221.                       e.printStackTrace();
  222.                      }
  223.                     }
  224.                   
  225.              } catch (ExecutionException e) {
  226.                  e.printStackTrace();
  227.              }
  228.             
  229.              try {
  230.                  System.out.println("\nFlux erreur : \n" + futureErreur.get());
  231.              } catch (ExecutionException e) {
  232.                  e.printStackTrace();
  233.              }
  234.          } catch (IOException e) {
  235.              e.printStackTrace();
  236.          } catch (InterruptedException e) {
  237.              e.printStackTrace();
  238.          }
  239.    }
  240.    else if( radio6.isSelected())// boutons radio pour la solution réalisable de gecode  
  241.    {
  242.     try {           
  243.               //Appel du programme C++ a partir de Java
  244.               ProcessBuilder pb = new ProcessBuilder("C:\\Users\\abdelhalim\\Desktop\\ReadInput.exe" );         
  245.               Process p = pb.start();           
  246.              
  247.              
  248.               //Creation de 2 threads pour lire les flux de sortie et derreur du programme C++
  249.               ExecutorService executor = Executors.newFixedThreadPool(2);
  250.              
  251.               Callable<String> callableFluxSortie = new AfficheurFlux(p.getInputStream());
  252.               Callable<String> callableFluxErreur = new AfficheurFlux(p.getErrorStream());
  253.              
  254.               Future<String> futureSortie = executor.submit(callableFluxSortie);
  255.               Future<String> futureErreur = executor.submit(callableFluxErreur);
  256.               executor.shutdown();
  257.              
  258.               OutputStream stdin = p.getOutputStream();
  259.               BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stdin));
  260.              
  261.               //nb ligne matrice
  262.               writer.write(String.valueOf(m));
  263.               writer.newLine();
  264.              
  265.              
  266.               //nb colonne matrice
  267.               writer.write(String.valueOf(n));
  268.               writer.newLine();
  269.              
  270.               writer.write(String.valueOf(m));
  271.               writer.newLine();
  272.              
  273.              
  274.               //nb colonne matrice
  275.               writer.write(String.valueOf(n));
  276.               writer.newLine();
  277.          
  278.            for(int i=0; i<R.size();i++)
  279.            { 
  280.             writer.write(String.valueOf(R.get(i)));
  281.                 writer.newLine();
  282.          
  283.            }
  284.            for(int i=0; i<C.size();i++)
  285.            { 
  286.             writer.write(String.valueOf(C.get(i)));
  287.                 writer.newLine();
  288.          
  289.            }
  290.            for(int i=0; i<B.size();i++)
  291.            { 
  292.             writer.write(String.valueOf(B.get(i)));
  293.                 writer.newLine();
  294.          
  295.            } for(int i=0; i<Dr.size();i++)
  296.            { 
  297.             writer.write(String.valueOf(Dr.get(i)));
  298.                 writer.newLine();
  299.          
  300.            } for(int i=0; i<Dc.size();i++)
  301.            { 
  302.             writer.write(String.valueOf(Dc.get(i)));
  303.                 writer.newLine();
  304.          
  305.            }
  306.            for(int i=0; i<Db.size();i++)
  307.            { 
  308.             writer.write(String.valueOf(Db.get(i)));
  309.                 writer.newLine();
  310.          
  311.            }
  312.            /*for(int k=0; k<n;k++)
  313.            {
  314.          for(int j=0; j<m;j++)
  315.           writer.write(String.valueOf(GainMatrix[k][j]));
  316.          writer.newLine();
  317.         }*/
  318.            writer.write(String.valueOf(n));
  319.                writer.newLine();
  320.            writer.write(String.valueOf(m));
  321.                writer.newLine();
  322.                writer.write(String.valueOf(m));
  323.                writer.newLine();
  324.                writer.write(String.valueOf(m));
  325.                writer.newLine();
  326.                writer.write(String.valueOf(n));
  327.                writer.newLine();
  328.            writer.write(String.valueOf(m));
  329.                writer.newLine();
  330.                writer.write(String.valueOf(n));
  331.                writer.newLine();
  332.            writer.write(String.valueOf(m));
  333.                writer.newLine();
  334.                writer.write(String.valueOf(n));
  335.                writer.newLine();
  336.            writer.write(String.valueOf(m));
  337.                writer.newLine();
  338.       
  339.               writer.flush();
  340.               writer.close();           
  341.              
  342.              
  343.               //Attente fin du programme C++
  344.               p.waitFor();
  345.              
  346.               try {
  347.                   System.out.println("\nFlux sortie : \n" + futureSortie.get());
  348.                   String resultat= futureSortie.get().toString();
  349.                  
  350.                   // convert String into InputStream
  351.                      InputStream is = new ByteArrayInputStream(resultat.getBytes());
  352.                      // read it with BufferedReader
  353.                      BufferedReader br = new BufferedReader(new InputStreamReader(is));
  354.                      String line;
  355.                      try {
  356.                       int nbLine = n+1;
  357.                       int nbCol = m;
  358.                       int cpt = 0;
  359.                       int[][] mat = new int[nbLine][nbCol];
  360.                       while ((line = br.readLine()) != null) {
  361.                        if(cpt>=nbLine) break;
  362.                               String[] split = line.trim().split("\\s+" );
  363.                        try{
  364.                         for(int i = 0; i<split.length && i<nbCol; i++){
  365.                          mat[cpt][i] = Integer.parseInt(split[i]);
  366.                         }
  367.                                  }
  368.                                  catch(NumberFormatException e){
  369.                                  }
  370.                        cpt++;
  371.                       }
  372.                       System.out.println("Matrice :" );
  373.                       for(int[] rows : mat){
  374.                        for(int cel : rows){
  375.                         System.out.print(cel + " " );
  376.                        }
  377.                        System.out.println();
  378.                       }
  379.                    
  380.                        res1= new int[nbLine-1][nbCol];
  381.                  
  382.                           int nRows = mat.length;
  383.                           int nColumns = mat[0].length;
  384.                      int newTabRow = 0;
  385.                          int newTabCol = 0;
  386.                    int index=0;
  387.                          for(int i = 0 ; i<nRows ; ++i){
  388.                              if(i != index){
  389.                                  for(int j = 0 ; j<nColumns ; ++j){
  390.                                     
  391.                                          res1[newTabRow][newTabCol] = mat[i][j];
  392.                                          ++newTabCol;
  393.                                     
  394.                                  }
  395.                                  ++newTabRow;
  396.                                  newTabCol = 0;
  397.                              }
  398.                          }
  399.                       for(int[] rows : res1){
  400.                              for(int cel : rows){
  401.                              System.out.print(cel + " " );
  402.                            System.out.println();
  403.                              }
  404.                        }
  405.                      } catch (IOException e) {
  406.                       e.printStackTrace();
  407.                      } finally {
  408.                       try {
  409.                        br.close();
  410.                       } catch (IOException e) {
  411.                        e.printStackTrace();
  412.                       }
  413.                      }
  414.                    
  415.               } catch (ExecutionException e) {
  416.                   e.printStackTrace();
  417.               }
  418.              
  419.               try {
  420.                   System.out.println("\nFlux erreur : \n" + futureErreur.get());
  421.               } catch (ExecutionException e) {
  422.                   e.printStackTrace();
  423.               }
  424.           } catch (IOException e) {
  425.               e.printStackTrace();
  426.           } catch (InterruptedException e) {
  427.               e.printStackTrace();
  428.           } 
  429.    }
  430.   }

 
 ce que je veux c'est que lorsque je sélectionne le bouton radio choco il reste sélctionné lorsque je sélectionne Optimal solution or fesable solution qui appartiennent à ce bouton et meme chose pour le bouton radio gecode  
 
Est ce que vous pouvez m'aider pour résoudre ce problème ???
 
est ce qu'il est préferable de choisir un autre moyen autre que les boutons radio pour satsfaire ces exégences ??  
 
Merci beaucoup pour votre aide  
 
 
 


---------------
when there is a will there is a way
mood
Publicité
Posté le 20-11-2013 à 21:38:08  profilanswer
 

n°2211236
lasnoufle
La seule et unique!
Posté le 21-11-2013 à 15:14:16  profilanswer
 

Salut

 

Ton probleme n'est pas dans le bout de code que tu as copie, mais dans le bout de code ou tu crees tes boutons (enfin je suppose).
En gros, tu as 6 boutons et tu voudrais qu'ils soient groupes deux par deux (choco/gecode, optimal/feasible pour choco, optimal/feasible pour gecode) c'est ca?
Alors que toi, d'apres ce que tu decris, tu as declare tes 6 boutons dans le meme groupe, donc tu ne peux en avoir qu'un seul de selectionne a la fois.
Tout ce que t'as a faire c'est de grouper tes boutons deux par deux quand tu les declares: au lieu d'utilise un seul ButtonGroup (nb: je suppose que c'est ce que tu fais... Il n'y a aucune indication sur quelles classes tu utilises dans le code que tu as copie), crees en trois et repartis tes boutons correctement.

 

A+

 

Edit: ou sinon, laisse tomber choco et gecode et n'utilise que 4 boutons:
choco optimal
choco feasible
gecode optimal
gecode feasible
Ca changera pas grand-chose a ton code poste.


Message édité par lasnoufle le 21-11-2013 à 15:16:14

---------------
C'était vraiment très intéressant.

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Java

  activer un bouton radio à partir d'un autre bouton radio en java

 

Sujets relatifs
Java - système de réservation de restaurant[JAVASCRIPT + HTML] Problème fonction Return
Java'sCool Ecrire dans un fichier.txtLes meilleurs tutoriels JAVA?
Activer/désactiver port avec coderéceptionner un matrice de c++ et la mettre dans une matrice en java
[Java] Page HTML de mon programmeenvoyer tout un vecteur comme un paramètre de Java en C + +
Java's cool 4 - Proglet polyominos - problème !Bouton + progressbar circulaire
Plus de sujets relatifs à : activer un bouton radio à partir d'un autre bouton radio en java



Copyright © 1997-2016 Hardware.fr SARL (Signaler un contenu illicite) / Groupe LDLC / Shop HFR