Fórum Distribuir tamanhos de acordo com a quantidade de cores #501081

13/11/2014

0

Estou fazendo um cadastro de itens pedidos para produção de camisas onde quem está comprando apenas informa o produto que quer(REFERENCIA), qtd total, e a distribuição por tamanho(quando informa, as vezes é baseado em grade 1 , 2 , 2 , 1 ou outra..).

exemplo:
REF = 9001, QTD_TOTAL= 85, T1(P)=15, T2(M)=20, T3(G)=25, T4(GG)=25


Preciso distribuir essa qtd informada em cores, exemplo: REF 9001 possui 3 cores, preciso distribuir essa qtd com essa grade em 3 cores diferentes da maneira mais igualável possível.

Exemplo de resultado:

REF = 9001 COR= VERMELHO T1=x T2=x T3=x T4=x
REF = 9001 COR= AMARELO T1=x T2=x T3=x T4=x
REF = 9001 COR= AZUL T1=x T2=x T3=x T4=x

Alguma ideia ? :S
Pedro Hugo

Pedro Hugo

Responder

Posts

13/11/2014

Ronaldo Lanhellas

Faltou bastante informações, vamos lá: O que vocÊ já tem pronto ? Quais frameworks está usando ? Poste o que você já tem.
Responder

Gostei + 0

20/11/2014

Pedro Hugo

Desculpa a demora, mas é que encontrei uma solução e tinha vários detalhes para corrigir.

Sou novo no java e o código ficou grande e para quem manja vai dizer porco, então nem vou postar :P

Mas se alguém estiver interessado eu mando.

Obrigado.
Responder

Gostei + 0

20/11/2014

Ronaldo Lanhellas

Tudo bem, mas acho difícil que alguém poste aqui a solução completa pra você. A ideia do fórum é você começar a criar e conforme os problemas forem surgindo, nós iremos lhe dar todo apoio com certeza.
Responder

Gostei + 0

20/11/2014

Pedro Hugo

Fmz :)
Tem algum lugar para fechar o tópico ?

Bom, meu código está funcionando tudo ok, mas como disse, com certeza tem como melhorar..
Se algum estudante quiser melhorar, ou postar alguma outra solução ou dar algumas dicas de como melhorar fique a vontade :)


Tenho um código que pega uma qtd_total da referencia e distribui nos tamanhos de acordo com a grade escolhida.
Após distribuir entre os tamanhos, vem a etapa de distribuir esses tamanhos entre as cores.
O código abaixo pega a qtd passada de cada tamanho e faz a distribuição.

public void dividir(double g1, double g2, double g3, double g4){
        
        Double qtd_total;
        Integer qtd_cor;
        Integer qtd_tamanho;
        
        Double qtd_por_cor;
        Double qtd_por_tamanho;
        
        Integer qtd_por_cor_inteiro;
        Integer qtd_por_tamanho_inteiro;
        Integer qtd_total_inteiro;
        
        Double sobra_por_cor;
        Integer sobra_por_cor_inteiro;
        Double sobra_por_tamanho;

        Integer tamanho_que_parou;

        
        DefaultTableModel model =  (DefaultTableModel) jTable1.getModel();
        
       
        
        
        //SE COR = TODAS
        if (combobox_cor.getSelectedItem().equals("TODAS")){
            
           System.out.println("Cor Selecionada: "+combobox_cor.getSelectedItem());
           //calculando qtd por qtd_cor_existente(todas)
 //*********qtd_total = Double.parseDouble(txt_qtd_total.getText());
           //pegando valor inteiro para fazer calculo da sobra
//**********qtd_total_inteiro = Integer.parseInt(txt_qtd_total.getText());
           qtd_cor = Integer.parseInt(txt_qtd_cores.getText());
           
           
           
              //********* DIVIDIR TAMANHOS DE ACORDO COM A GRADE INFORMADA *********  
           //Pegando quantos tamanhos tem
           qtd_tamanho = Integer.parseInt(txt_qtd_tamanho.getText());
           
           //colocar if para tamanho = 3 (especial)
           
            //pegando grades inseridas
            Integer t1_grade_inteiro = (int)g1;
            Integer t2_grade_inteiro = (int)g2;
            Integer t3_grade_inteiro = (int)g3;
            Integer t4_grade_inteiro = (int)g4;
            
            Double t1_grade = g1;
            Double t2_grade = g2;
            Double t3_grade = g3;
            Double t4_grade = g4;
           
            //calculando sobra dos tamanhos
            Double qtd_t1 = t1_grade/qtd_cor;
            Double qtd_t2 = t2_grade/qtd_cor;
            Double qtd_t3 = t3_grade/qtd_cor;
            Double qtd_t4 = t4_grade/qtd_cor;
           //qtd por tamanho int
           Integer qtd_t1_inteiro = t1_grade_inteiro/qtd_cor;
           Integer qtd_t2_inteiro = t2_grade_inteiro/qtd_cor;
           Integer qtd_t3_inteiro = t3_grade_inteiro/qtd_cor;
           Integer qtd_t4_inteiro = t4_grade_inteiro/qtd_cor;
           //sobra
           //t1
           Double sobra_t1 = (qtd_t1-qtd_t1_inteiro)*qtd_cor;
           System.out.println("Sobra t1: "+sobra_t1);
           Integer sobra_t1_inteiro = (int)Math.round(sobra_t1);
           
           //t2
           Double sobra_t2 = (qtd_t2-qtd_t2_inteiro)*qtd_cor;
            System.out.println("Sobra t2: "+sobra_t2);
           Integer sobra_t2_inteiro = (int)Math.round(sobra_t2);
           
           //t3
           Double sobra_t3 = (qtd_t3-qtd_t3_inteiro)*qtd_cor;
           System.out.println("Sobra t3: "+sobra_t3);
           Integer sobra_t3_inteiro = (int)Math.round(sobra_t3);
           
           //t4
           Double sobra_t4 = (qtd_t4-qtd_t4_inteiro)*qtd_cor;
           System.out.println("Sobra t4: "+sobra_t4);
           Integer sobra_t4_inteiro = (int)Math.round(sobra_t4);
           
            
            //adicionando qtds no array de cada tamanho de acordo com a qtd de cores
            int[] t1 = new int[14];
            int[] t2 = new int[14];
            int[] t3 = new int[14];
            int[] t4 = new int[14];
            
            //SE I = 1 ENTAO COR 1..
            for (int i = 0; i <= qtd_cor; i++) {
                t1[i]=t1_grade_inteiro/qtd_cor;
                t2[i]=t2_grade_inteiro/qtd_cor;
                t3[i]=t3_grade_inteiro/qtd_cor;
                t4[i]=t4_grade_inteiro/qtd_cor;
                
            }
            System.out.println("Divisões iguais:");
            System.out.println(" T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
            
            //sorterar cor para iniciar
            Random gerador = new Random();
            Integer cor_que_parou = gerador.nextInt(3) + 1;
            System.out.println("--------------------------Cor que parou gerado: "+cor_que_parou);
            
            //Integer cor_que_parou = 3;
            
             
            
            //************Dividindo cores do ---T1---- ************
            
            if (cor_que_parou == 3) {
                    System.out.println("Adicionando sobra T1 começando na 1 cor");
                                        switch (sobra_t1_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t1[1] = t1[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t1[1] = t1[1]+1;//+
                                                     t1[2] = t1[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 1************
            else if (cor_que_parou == 1) {
                    System.out.println("Adicionando sobra T1 começando na 2 cor");
                                        switch (sobra_t1_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t1[2] = t1[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t1[2] = t1[2]+1;//+
                                                     t1[3] = t1[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 2************
            else if (cor_que_parou == 2) {
                    System.out.println("Adicionando sobra T1 começando na 3 cor");
                                        switch (sobra_t1_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t1[3] = t1[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t1[3] = t1[3]+1;//+
                                                     t1[1] = t1[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*************FIM DIVIDIR CORES --T1--- ***********
            
           //************Dividindo cores do ---T2---- ************
            
            if (cor_que_parou == 3) {
                    System.out.println("Adicionando sobra T2 começando na 1 cor");
                                        switch (sobra_t2_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t2[1] = t2[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t2[1] = t2[1]+1;//+
                                                     t2[2] = t2[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 1************
            else if (cor_que_parou == 1) {
                    System.out.println("Adicionando sobra T2 começando na 2 cor");
                                        switch (sobra_t2_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t2[2] = t2[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t2[2] = t2[2]+1;//+
                                                     t2[3] = t2[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                           System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 2************
            else if (cor_que_parou == 2) {
                    System.out.println("Adicionando sobra T2 começando na 3 cor");
                                        switch (sobra_t2_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t2[3] = t2[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t2[3] = t2[3]+1;//+
                                                     t2[1] = t2[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*************FIM DIVIDIR CORES --T2--- ***********
            
            
            //************Dividindo cores do ---T3---- ************
            
            if (cor_que_parou == 3) {
                    System.out.println("Adicionando sobra T3 começando na 1 cor");
                                        switch (sobra_t3_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t3[1] = t3[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t3[1] = t3[1]+1;//+
                                                     t3[2] = t3[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 1************
            else if (cor_que_parou == 1) {
                    System.out.println("Adicionando sobra T3 começando na 2 cor");
                                        switch (sobra_t3_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t3[2] = t3[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t3[2] = t3[2]+1;//+
                                                     t3[3] = t3[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                          System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 2************
            else if (cor_que_parou == 2) {
                    System.out.println("Adicionando sobra T3 começando na 3 cor");
                                        switch (sobra_t3_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t3[3] = t3[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t3[3] = t3[3]+1;//+
                                                     t3[1] = t3[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*************FIM DIVIDIR CORES --T3--- ***********
            
            //************Dividindo cores do ---T4---- ************
            
            if (cor_que_parou == 3) {
                    System.out.println("Adicionando sobra T4 começando na 1 cor");
                                        switch (sobra_t4_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t4[1] = t4[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t4[1] = t4[1]+1;//+
                                                     t4[2] = t4[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 1************
            else if (cor_que_parou == 1) {
                    System.out.println("Adicionando sobra T4 começando na 2 cor");
                                        switch (sobra_t4_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t4[2] = t4[2]+1;//+
                                                     cor_que_parou = 2;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t4[2] = t4[2]+1;//+
                                                     t4[3] = t4[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                           System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*********SE PAROU NO 2************
            else if (cor_que_parou == 2) {
                    System.out.println("Adicionando sobra T4 começando na 3 cor");
                                        switch (sobra_t4_inteiro) {
                                                     case 1:
                                                     {
                                                     System.out.println("Sobrou 1");
                                                     t4[3] = t4[3]+1;//+
                                                     cor_que_parou = 3;
                                                     break;
                                                     }
                                                     case 2:
                                                     {
                                                     System.out.println("Sobrou 2");
                                                     t4[3] = t4[3]+1;//+
                                                     t4[1] = t4[1]+1;//+
                                                     cor_que_parou = 1;
                                                     break;
                                                     }
                                                     default:{
                                                     System.out.println("Sobrou 3, divisão igual");
                                                     
                                                     }  
                                                     

                                                 }
                                            System.out.println(" COR 1: T1: "+t1[1]+" T2: "+t2[1]+" T3: "+t3[1]+" T4: "+t4[1]);
                                            System.out.println(" COR 2: T1: "+t1[2]+" T2: "+t2[2]+" T3: "+t3[2]+" T4: "+t4[2]);
                                            System.out.println(" COR 3: T1: "+t1[3]+" T2: "+t2[3]+" T3: "+t3[3]+" T4: "+t4[3]);
                                        }//fim if continuar de onde parou.
            
            //*************FIM DIVIDIR CORES --T4--- ***********
            
            
            
       //**********RESULTADO FINAL:     
             
            if (qtd_tamanho==4){ //se normal
                        
                        //Imprimir Qtd de acordo com qtd de cores
                        for (int y = 1; y <= qtd_cor; y++) {
                                
                                //System.out.println("REF: "+txt_ref.getText()+" T1: "+t1[y]+" T2: "+t2[y]+" T3: "+t3[y]+" T4: "+t4[y]+ " Cor: "+combobox_cor.getItemAt(y)+" Tipo: "+combobox_cor.getSelectedItem());
                                //int total = t1[y]+t2[y]+t3[y]+t4[y];
                                //model.addRow(new Object[]{"id",txt_ref.getText(), combobox_cor.getItemAt(y), t1[y], t2[y], t3[y], t4[y], combobox_cor.getSelectedItem(), total});
                                
                                //adicionando ao banco de dados e listando
                                adiciona_item(y, t1[y],t2[y],t3[y],t4[y]);
                        }
                }
                else { //tamanho != 4 (ESPECIAL) //nem precisava mas deixei :S
                       //Imprimir Qtd de acordo com qtd de cores
                        for (int y = 1; y <= qtd_cor; y++) {
                                //System.out.println("REF: "+txt_ref.getText()+" T1: "+t1[y]+" T2: "+t2[y]+" T3: "+t3[y]+" Cor: "+combobox_cor.getItemAt(y)+" Tipo: "+combobox_cor.getSelectedItem());
                                //int total = t1[y]+t2[y]+t3[y];
                                //model.addRow(new Object[]{"id",txt_ref.getText(), combobox_cor.getItemAt(y), t1[y], t2[y], t3[y], t4[y], combobox_cor.getSelectedItem(), total});
                                
                                //adicionando ao banco de dados
                                adiciona_item(y, t1[y],t2[y],t3[y],t4[y]);
                        }
                }
            
        }else{//SE FOR UMA COR
        
            
            //***************************UMA COR********************
           System.out.println("Uma cor");
        
           System.out.println("Cor Selecionada: "+combobox_cor.getSelectedItem());
           //calculando qtd por uma cor
           qtd_total = Double.parseDouble(txt_qtd_total.getText());
           qtd_total_inteiro = Integer.parseInt(txt_qtd_total.getText());
            
           //Pegando quantos tamanhos tem
           qtd_tamanho = Integer.parseInt(txt_qtd_tamanho.getText());
           
           //pegando grades inseridas
                        Integer t1_grade_inteiro = (int)g1;
                        Integer t2_grade_inteiro = (int)g2;
                        Integer t3_grade_inteiro = (int)g3;
                        Integer t4_grade_inteiro = (int)g4; 
           
           //SE qtd tamanho = 4 (normal)
                if (qtd_tamanho==4){
                        
                        //resultado  
                        System.out.println("REF: "+txt_ref.getText()+" Cor: "+combobox_cor.getSelectedItem()+" T1: "+t1_grade_inteiro+" T2: "+t2_grade_inteiro+" T3: "+t3_grade_inteiro+" T4: "+t4_grade_inteiro);
                        
                        //int total = t1_grade_inteiro+t2_grade_inteiro+t3_grade_inteiro+t4_grade_inteiro;
                        //model.addRow(new Object[]{"id",txt_ref.getText(), combobox_cor.getSelectedItem(), t1_grade_inteiro, t2_grade_inteiro, t3_grade_inteiro, t4_grade_inteiro, combobox_cor.getSelectedItem(), total});
                        
                        
                        //adicionando ao banco de dados
                        adiciona_item(combobox_cor.getSelectedIndex(), t1_grade_inteiro,t2_grade_inteiro,t3_grade_inteiro,t4_grade_inteiro);
                }
                else { //tamanho != 4 (ESPECIAL)
                        System.out.println("REF: "+txt_ref.getText()+" Cor: "+combobox_cor.getSelectedItem()+" T1: "+t1_grade_inteiro+" T2: "+t2_grade_inteiro+" T3: "+t3_grade_inteiro);
                        //int total = t1_grade_inteiro+t2_grade_inteiro+t3_grade_inteiro;
                        //model.addRow(new Object[]{"id",txt_ref.getText(), combobox_cor.getSelectedItem(), t1_grade_inteiro, t2_grade_inteiro, t3_grade_inteiro, t4_grade_inteiro, combobox_cor.getSelectedItem(), total});
                        
                        //adicionando ao banco de dados
                        adiciona_item(combobox_cor.getSelectedIndex(), t1_grade_inteiro,t2_grade_inteiro,t3_grade_inteiro,t4_grade_inteiro);
                }
        }//fim uma cor
        
        
    } //fim Metodo Dividir();
    
Responder

Gostei + 0

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar