[java] come faccio ?

[keratox]

Spiego brevemente la situazione:
sto facendo un editor di testo e uso JTabbedPane; c'è un bottone per creare un nuovo foglio (inteso come nuovo Tab con 1 jtextarea) e un altro bottone per cancellare i fogli.
Siccome i tab hanno il nome che termina con il numero di tab aperto, se li cancello e ne creo nuovi, mi succede un gran casino. Ho usato una variabile (out) per tenere conto del tab da creare, ma in questo modo mi tiene in memoria solo 1 tab.
Anche se uso gli array(cosa che poi mi tocca ) non so come fare

mi direste la procedura da seguire?

[anx721]

Spiega meglio cos'è che vuoi fare è qual è il problema

[LeleFT]

Non ho capito se ti interessa avere tenere conto delle posizioni vuote create dalle eliminazioni da poter riempire con i nuovi tab eventualmente creati, o se ti interessa aggiungere all fine un nuovo tab con un progressivo coerente (spiegando cosa intendi per coerente).


Ciao.

[keratox]

|__1__|__2__|__3__|

mettiamo che uno apre i JTabbedPane così

se io cancello il 2

|__1__|__3__|

e poi ne creo uno nuovo, fa così:

|__1__|__3__|__2__|

ma se cancello 3 e 2

|__1__|

e poi ne creo altri, mi crea il 2 (perche' e' stato l'ultimo ad essere cancellato) e poi il 4,5,6,7,8,9

|__1__|__2__|__4__|__5__|

come faccio ad evitare sto problema?

[anx721]

Ma perchè non ti crea il 3? Qual è il modo in cui ti crei i nomi dei pannelli?

[keratox]

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class robyed extends JFrame implements ActionListener{
	
	
	JTextArea testo[] = new JTextArea[24];
	int testo_ = 0,out=0,i=0;
	int out2[] = new int[24];
	JTabbedPane jtb;

robyed(){
	super("Keratox Editor v. 1.0");
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	setBounds(100,80,500,470);
	
....

miesciall.addActionListener(this);
miesci.addActionListener(this);
minew.addActionListener(this);

testo[testo_]= new JTextArea(22,65);

	
	mfile.add(minew);
	mfile.add(miopen);
	mfile.add(misalva);
	mfile.add(miprint);
	mfile.add(miesci);
	mfile.add(miesciall);
....
	
    jtb = new JTabbedPane();
	
	JPanel pan = new JPanel();
	setContentPane(pan);
	
	jtb.addTab("Untitled" + testo_, testo[testo_]); 
    getContentPane().add(jtb); 
}

public void actionPerformed(ActionEvent ae){
	Object sae = ae.getSource();
	if(sae==otcol){
    this.wh="colore";
	finestra win = new finestra();
	}
	
	if(sae==miesciall){
		System.exit(0);
	}	
	if(sae==miesci){
		if(jtb.getTabCount()==1){
		System.exit(0);	
		}
		else if(jtb.getTabCount()>1){
		out = jtb.getSelectedIndex();
		jtb.removeTabAt(jtb.getSelectedIndex());
		}	
	}
	if(sae==minew){
		if(out==0){
       	testo_++;
       	testo[testo_]= new JTextArea(22,65);
       	jtb.addTab("Untitled" + testo_, testo[testo_]);
        jtb.setSelectedIndex(testo_);
        } else{
        	  testo[out]= new JTextArea(22,65);
        	  jtb.addTab("Untitled" + out, testo[out]);
              jtb.setSelectedIndex(out);
              out=0;
        }
 	}

}

public static void main(String[] args){
....
	robyed red = new robyed();
	red.show();
}

[LeleFT]

Puoi usare un array dinamico:
l'array deve sempre essere di dimensione pari all'indice più alto del tab presente.
Poi tieni una variabile che indica il più basso numero disponibile per la creazione (ossia la più bassa cella dell'array che sia vuota, per capirci).
In questo modo sai sempre qual'è il numero da mettere nella nuova tab. Provo a spiegarmi graficamente:

All'inizio, dopo 3 creazioni hai questa situazione:
TAB: |__1__|__2__|__3__|

Array: |__X__|__X__|__X__|

Variabile: 4

Poi elimini, per esempio il 2 (la B indica che la cella è vuota):

TAB: |__1__|__3__|

Array: |__X__|__B__|__X__|

Variabile: 2

Poi elimini il 3:

TAB: |__1__|

Array: |__X__|

Variabile: 2

Se, invece, ai punti precedenti, aggiungevi il 3 e il 4 e poi eliminavi il 2 e il 3, succedeva questo:

TAB: |__1__|__4__|

Array: |__X__|__B__|__B__|__X__|

Variabile: 2

Ogni volta che elimini un elemento controlli se ridimensionare o meno l'array (è facile: controlli se l'indice della tab che elimini è uguale al length dell'array)

Poi fai una scansione dell'array e, al primo posto vuoto che trovi, lì ti fermi e metti la variabile al valore di quell'indice.

Spero di essermi spiegato bene.


Ciao.

[keratox]

apprezzo il tuo consiglio ma non ho capito tanto bene

[LeleFT]

Ho realizzato una classe al volo: visualizza nella consolle l'array dei tabs ad ogni passaggio e la posizione vuota tenuta.
Prima di cliccare sul pulsante "Togli" scrivi nella TextField la tab da togliere (ho fatto partire l'array dal valore 1 e non dallo 0!!)

import java.awt.*;
import java.awt.event.*;
public class Prova extends Frame {

   private Button b, b2;
   private TextField txt;
   private int v;
   private int [] tabs;

   public Prova() {
      setLayout(null);
      b = new Button("Aggiungi");
      b.setBounds(30, 30, 150, 30);
      b2 = new Button("Togli");
      b2.setBounds(30, 100, 150, 30);
      txt = new TextField();
      txt.setBounds(200, 200, 50, 30);
      tabs = new int[0];
      v = 1;

      b.addActionListener( new ActionListener() {
         public void actionPerformed(ActionEvent ae) { aggiungi(); }
      });

      b2.addActionListener( new ActionListener() {
         public void actionPerformed(ActionEvent ae) { togli(); }
      });

      add(b);
      add(b2);
      add(txt);
      setSize(300, 300);
      setVisible(true);
   }

   private void aggiungi() {
      if (v > tabs.length) {
         int [] tmp = new int[tabs.length];
         for (int i=0; i<tabs.length; i++) tmp[i] = tabs[i];
         tabs = new int[tmp.length+1];
         for (int i=0; i<tmp.length; i++) tabs[i] = tmp[i];
      }
      tabs[v-1] = v;
      scandisci();
      for (int i=0; i<tabs.length; i++) System.out.print(" " + tabs[i]);
      System.out.println();
      System.out.println("Posizione vuota: "+ v);
   }
   private void togli() {
      int t = Integer.parseInt(txt.getText());
      tabs[t-1] = 0;
      if (t == tabs.length) {
         int [] tmp = new int[tabs.length-1];
         for (int i=0; i<tabs.length-1; i++) tmp[i] = tabs[i];
         tabs = new int[tmp.length-1];
         for (int i=0; i<tmp.length; i++) tabs[i] = tmp[i];
      }
      scandisci();
      for (int i=0; i<tabs.length; i++) System.out.print(" " + tabs[i]);
      System.out.println();
      System.out.println("Posizione vuota: "+ v);
   }
   private void scandisci() {
      int i=1;
      boolean trovato = false;
      while (((i-1)<tabs.length) && !trovato) {
         if (tabs[i-1] == 0) trovato = true;
         else i++;
      }
      v = i;
   }
   public static void main(String [] args) { Prova p = new Prova(); }
}

Questo fa quello che vuoi tu (spero!) :gren:

Ciao.

[keratox]

Perfetto. Ti ringrazio ^__^

ciauz