Skip to content

Instantly share code, notes, and snippets.

@TonyWhite

TonyWhite/Conversioni.java

Created August 26, 2012 16:19
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save TonyWhite/3481431 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save TonyWhite/3481431 to your computer and use it in GitHub Desktop.
Download ZIP
Sistemi Di Numerazione
Raw
Conversioni.java
/**
* La classe converte da un sistema decimale ad un sistema qualsiasi e viceversa
*
* Autore: Antonio Bianco
*/
public class Conversioni implements Runnable
{
public static final String ERRORE = "Err";
public static final long MAX_DEC = 9999999999999990L; // Numero decimale più grande da convertire
/**
* Constructor for objects of class Conversioni
*/
public Conversioni()
{
// Metodo vuoto
}
/**
* Converte un carattere nel relativo codice ASCII nella base specificata
*
* char carattere: il carattere da codificare
* int base: la base di codifica
*
* Esempio:
* carattere = 'A'
* base = 2
* codice ASCII = 65
* return: "1000001"
*/
public static String charToBase(char carattere, int base)
{
return decToBase(((int)carattere)+"", base);
}
/**
* Converte un numero in base 10 in un qualsiasi altra base
*
* String num: numero in base 10
* int base: la base nella quale convertire
* return: la stringa che rappresenta il numero convertito
*
* Nota 1: La conversione è assicurata solo per numeri interi positivi fino a 9999999999999990
* Nota 2: base <= 36 perché le cifre rappresentate con le lettere dell'alfabeto sono solo maiuscole
*/
public static String decToBase(String num, int base)
{
/**
* Oltre 9999999999999990 il double non riesce a gestire con precisione tutti i decimali
*/
String valore = ERRORE;
try
{
if (numeroValido_privato(num, 10)) //Assicuriamoci che il numero inserito sia in base 10
{
valore = "";
Long intero = new Long(num); // Istruzione con pericolo di overflow
if (intero > MAX_DEC)
{
valore = ERRORE + ": num deve essere < " + MAX_DEC;
}
else
{
if (base==1) // Calcola per la base più inutile e pericolosa in assoluto
{
/**
* Con il massimo valore possibile 9'999'999'999'999'990 si consuma una quatara di RAM.
* Ogni carattere della stringa è rappresentato da 16 bit,
* quindi il consumo massimo sarebbe di (9'999'999'999'999'990+1)*2 byte
* che sarebbero 19'999'999'999'999'982 byte
* che sarebbero 19'073'486'328,1 MB
* che sarebbero 18'626'451,4923 GB
* che sarebbero cazzi amari espressi in potenze di 2
* E allora perché non ho messo un controllo per limitare lo spreco di memoria?
* 1) Per vedere chi è tanto http://lmgtfy.com/?q=persona+poco+avveduta+che+non+prevede+le+conseguenze+dei+propri+atti+per+insufficiente+intelligenza&l=1
* 2) Me lo ha chiesto Fabio (no, non è quello di Striscia)
*/
/*for (int i=0; i<=intero; i++) // Per il ciclo alta tensione...
{
valore += "0";
}*/
valore = ERRORE; // DEBUG: Questo metodo non è sicuro per compiere questa conversione
}
else // Calcola per tutte le altre basi
{
Long risultato;
Double decimale;
while(intero>0)
{
decimale = intero.doubleValue()/base; // In realtà la vera trappola non è l'overflow del Long, ma la notazione del double che perde precisione oltre un certo valore (definito in MAX_DEC)
intero = decimale.longValue(); // Prendo la parte intera del numero
decimale = decimale - intero.doubleValue(); // Prendo la parte decimale del numero
risultato = Math.round(new Double(base*decimale)); // Prendo il risultato
valore = valoreCifra(risultato.byteValue()) + valore; // Aggiorno il risultato
}
}
}
}
else
{
valore = ERRORE;
}
}
catch(Exception e)
{
valore = ERRORE;
}
return valore;
}
/**
* Ritorna la cifra in base 36 che rappresenta il valore in base decimale dato in input
*/
private static char valoreCifra(byte valore)
{
if (valore<10) valore += 48;
else valore += 55;
return (char)valore;
}
/**
* Converte un numero in base decimale
*
* String num: numero da convertire
* int base: base del numero da convertire
* return: una stringa che rappresenza il numero num convertito in decimale
*
* Nota 1: Il metodo controlla che il numero in input sia valido
* Nota 2: La conversione è assicurata solo per numeri interi positivi fino a Long.MAX_VALUE
* Nota 3: base<=36 perché le cifre rappresentate con le lettere dell'alfabeto sono solo maiuscole
*/
public static String baseToDec(String num, int base)
{
String risultato = ERRORE;
long risultato_num = 0;
num = num.toUpperCase();
if (numeroValido_privato(num, base)) // Numero valido
{
if (base==1) // Se la base è 1
{
int numero = num.length();
numero--;
risultato = numero+"";
}
else if (base==10) // Se la base è già decimale
{
try
{
// non convertire niente
long numero = new Long(num); // Ma rendilo almeno leggibile
risultato = numero + "";
}
catch(Exception e)
{
// Impossibile, tanto il numero è stato verificato prima, ed È decimale. In ogni caso...
risultato = ERRORE;
}
}
else // Per tutte le altre basi
{
risultato = "";
double j=num.length(); // Esponente per il calcolo
for (int i=0; i<num.length(); i++)
{
j--;
byte cifra = (byte)num.charAt(i);
if (cifra<=57) cifra -= 48;
else cifra -= 55;
double conversione = cifra*(Math.pow(base, j));
risultato_num += conversione;
}
risultato = "" + risultato_num;
}
}
else risultato = ERRORE;
return risultato;
}
/**
* Verifica se la cifra può essere espressa con la base indicata
*
* String num: numero da verificare
* int base: base per la quale verificare
* return: ritorna true se il numero può essere espresso nella base indicata
*
* Nota: il metodo è privato ed è più snello
*/
private static boolean numeroValido_privato(String num, int base)
{
/**
* Intervalli
* 0...9 = 48...57
* A...Z = 65...90
* la differenza tra il codice ascii della cifra e della base è:
* --> 47 quando la base è minore di 10
* --> 54 quando la base è almeno 11
*/
boolean valido = true;
if ((base>0)&&(base<=36)) // Verifica che la base scelta sia gestibile
{
for (int i=0; (i<num.length())&&(valido); i++)
{
byte ascii = (byte)num.charAt(i);
if (ascii==48) // Lo zero è compreso in tutte le basi
{
valido = true;
}
else
{
// Verifica che la cifra sia rappresentabile nella base indicata
if (((ascii>48)&&(ascii<=57))||((ascii>=65)&&(ascii<=90)))
{
int differenza = 54;
if (base<=10) differenza = 47;
if ((ascii-base)<=differenza) valido = true;
else valido = false;
}
else valido = false;
}
}
}
else
{
valido = false;
}
return valido;
}
/**
* Verifica se la cifra può essere espressa con la base indicata
*
* String num: numero da verificare
* int base: base per la quale verificare
* return: ritorna true se il numero può essere espresso nella base indicata
*/
public static boolean numeroValido(String num, int base)
{
/**
* Intervalli
* 0...9 = 48...57
* A...Z = 65...90
* la differenza tra il codice ascii della cifra e della base è:
* --> 47 quando la base è minore di 10
* --> 54 quando la base è almeno 11
*/
boolean valido = true;
num = num.toUpperCase();
if ((base>0)&&(base<=36)) // Verifica che la base scelta sia gestibile
{
for (int i=0; (i<num.length())&&(valido); i++)
{
byte ascii = (byte)num.charAt(i);
if (ascii==48) // Lo zero è compreso in tutte le basi
{
valido = true;
}
else
{
// Verifica che la cifra sia rappresentabile nella base indicata
if (((ascii>48)&&(ascii<=57))||((ascii>=65)&&(ascii<=90)))
{
int differenza = 54;
if (base<=10) differenza = 47;
if ((ascii-base)<=differenza) valido = true;
else valido = false;
}
else valido = false;
}
}
}
else
{
valido = false;
}
return valido;
}
/**
* Thread per salvaguardare la conversione più rischiosa: da decimale a base 1
*/
public void run()
{
while(true)
{
try
{
Thread.sleep(100);
}
catch(Exception e){}
}
}
}
Raw
Finestra.java
/**
* La finestra principale
*
* Autore: Antonio Bianco
*/
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Font;
import java.awt.FlowLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.net.URL;
import javax.swing.Action;
import javax.swing.BoxLayout;
import javax.swing.ComboBoxEditor;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JCheckBox;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JSpinner;
import javax.swing.JSpinner.DefaultEditor;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SpinnerListModel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.text.DefaultEditorKit;
import java.util.HashMap;
public class Finestra extends JFrame implements ActionListener, WindowListener, ChangeListener, Runnable
{
// Componenti grafici
JButton btnConverti;
JButton btnInverti;
JButton btnEsci;
JComboBox cbbDa;
JComboBox cbbA;
JProgressBar progress;
JTextArea txtDa;
JTextArea txtA;
JPopupMenu menuDa, menuA;
// Componenti grafici delle opzioni
JComboBox cbbTemi;
JComboBox cbbFont;
JCheckBox ckbGrassetto;
JCheckBox ckbCorsivo;
JSpinner spnDimensioneFont;
JTextArea txtAnteprima;
// Stato del programma
boolean conversione = false;
/**
* Costruttore
*/
public Finestra()
{
super("Sistemi di numerazione");
this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
this.addWindowListener(this);
this.impostaIcona("img/48/binary.png");
// Inizializzazione dei font
//font = new Font(Opzioni.FONT_NAME, Opzioni.FONT_STILE, Opzioni.FONT_SIZE);
Font font = new Font(Opzioni.FONT_NAME, Opzioni.FONT_STILE, Opzioni.FONT_SIZE);
// Inizializzazione della lista dei combo box
String[] listacodifiche = new String[37];
listacodifiche[0] = "TESTO";
for (int i=1; i<listacodifiche.length; i++)
{
String voce = i+"";
switch (i)
{
case 2: voce += " (BIN)";
break;
case 8: voce += " (OCT)";
break;
case 10: voce += " (DEC)";
break;
case 16: voce += " (HEX)";
break;
}
listacodifiche[i] = voce;
}
/****************************
* Creazione dei componenti *
****************************/
// Creazione dei CheckBox
ckbGrassetto = new JCheckBox("Grassetto");
if ((Opzioni.FONT_STILE==Font.BOLD)||(Opzioni.FONT_STILE==Font.BOLD+Font.ITALIC)) ckbGrassetto.setSelected(true); // Seleziona il componente solo se il testo è grassetto
ckbGrassetto.addActionListener(this);
ckbCorsivo = new JCheckBox("Corsivo");
if ((Opzioni.FONT_STILE==Font.ITALIC)||(Opzioni.FONT_STILE==Font.BOLD+Font.ITALIC)) ckbCorsivo.setSelected(true); // Seleziona il componente solo se il testo è corsivo
ckbCorsivo.addActionListener(this);
// Creazione dei combo box
cbbDa = new JComboBox(listacodifiche);
//cbbDa.setEditable(true);
cbbDa.addActionListener(this);
cbbA = new JComboBox(listacodifiche);
//cbbA.setEditable(true);
cbbA.addActionListener(this);
cbbTemi = new JComboBox(Opzioni.TEMI);
cbbTemi.setSelectedItem(Opzioni.TEMA_CORRENTE); // Seleziona il tema corrente
cbbTemi.addActionListener(this);
cbbFont = new JComboBox(Opzioni.LISTA_FONT);
cbbFont.setSelectedItem(Opzioni.FONT_NAME); // Seleziona il font corrente
cbbFont.setToolTipText(Opzioni.FONT_NAME); // Imposta il tooltip
System.out.println("cbbFont.getPrototypeDisplayValue() = " + cbbFont.getPrototypeDisplayValue());
cbbFont.setPrototypeDisplayValue("1234567890123456789012345"); // Imposta la larghezza del combobox a 25 caratteri
cbbFont.addActionListener(this);
// Inizializzazione dello spinner per la dimensione dei font
String[] dimensioniCaratteri = new String[100]; // Array delle dimensioni da utilizzare
for (int i=0; i<100; i++) dimensioniCaratteri[i] = (i+1) + ""; // Si utilizzano dimensioni di carattere da 1 a 100
SpinnerListModel modelloDimensioneCaratteri = new SpinnerListModel(dimensioniCaratteri); // Si crea il modello di Spinner con le dimensioni di caratteri
spnDimensioneFont = new JSpinner(modelloDimensioneCaratteri); // Si crea lo spinner con le dimensioni di caratteri da utilizzare
{
// Formatta il componente
JComponent editor = spnDimensioneFont.getEditor();
if (editor instanceof DefaultEditor)
{
((DefaultEditor)editor).getTextField().setColumns(3); // Imposta una larghezza per 3 caratteri
((DefaultEditor)editor).getTextField().setHorizontalAlignment(JTextField.RIGHT); // Allineamento del testo a destra
}
}
// Visualizza la dimensione del font corrente
spnDimensioneFont.setValue(Opzioni.FONT_SIZE+"");
spnDimensioneFont.setToolTipText("Dimensione del font");
spnDimensioneFont.addChangeListener(this);
// Inizializzazione dei bottoni
btnConverti = new JButton("Converti");
btnConverti.setToolTipText("Converte nella base specificata");
btnConverti.addActionListener(this);
btnInverti = new JButton("Inverti");
btnInverti.setToolTipText("Inverti i risultati nelle aree di testo");
btnInverti.addActionListener(this);
btnEsci = new JButton("Esci");
btnEsci.setToolTipText("Esce dall'applicazione");
btnEsci.addActionListener(this);
// Inizializzazione della ProgressBar
progress = new JProgressBar(SwingConstants.HORIZONTAL);
// Aree di testo con scrolling e testo monospace
txtDa = new JTextArea();
txtDa.setFont(font);
txtDa.setEditable(true);
txtDa.setAutoscrolls(true);
txtDa.setTabSize(2);
txtDa.setLineWrap(true);
txtDa.setWrapStyleWord(true);
{
/**
* Crea le azioni copia/taglia/incolla per il componente
* Crea il menu delle azioni
* http://docs.oracle.com/javase/tutorial/uiswing/components/generaltext.html#commands
*/
HashMap<Object, Action> mappaAzioni = new HashMap<Object, Action>();
Action[] azioni = txtDa.getActions();
for (int i = 0; i < azioni.length; i++) mappaAzioni.put(azioni[i].getValue(Action.NAME), azioni[i]);
menuDa = new JPopupMenu(); // Crea il menu per questo componente
menuDa.setBorder(javax.swing.BorderFactory.createLineBorder(java.awt.Color.GRAY)); // Crea un bordo nero intorno al menu
{
JMenuItem menuTaglia = new JMenuItem(mappaAzioni.get(DefaultEditorKit.cutAction));
menuTaglia.setText("Taglia");
menuDa.add(menuTaglia);
JMenuItem menuCopia = new JMenuItem(mappaAzioni.get(DefaultEditorKit.copyAction));
menuCopia.setText("Copia");
menuDa.add(menuCopia);
JMenuItem menuIncolla = new JMenuItem(mappaAzioni.get(DefaultEditorKit.pasteAction));
menuIncolla.setText("Incolla");
menuDa.add(menuIncolla);
menuDa.addSeparator();
JMenuItem menuSelezionaTutto = new JMenuItem(mappaAzioni.get(DefaultEditorKit.selectAllAction));
menuSelezionaTutto.setText("Seleziona tutto");
menuDa.add(menuSelezionaTutto);
}
txtDa.setComponentPopupMenu(menuDa);
}
JScrollPane scrollDa = new JScrollPane(txtDa);
txtA = new JTextArea();
txtA.setFont(font);
txtA.setEditable(true);
txtA.setAutoscrolls(true);
txtA.setTabSize(2);
txtA.setLineWrap(true);
txtA.setWrapStyleWord(true);
{
/**
* Crea le azioni copia/taglia/incolla per il componente
* Crea il menu delle azioni
* http://docs.oracle.com/javase/tutorial/uiswing/components/generaltext.html#commands
*/
HashMap<Object, Action> mappaAzioni = new HashMap<Object, Action>();
Action[] azioni = txtA.getActions();
for (int i = 0; i < azioni.length; i++) mappaAzioni.put(azioni[i].getValue(Action.NAME), azioni[i]);
menuA = new JPopupMenu(); // Crea il menu per questo componente
menuA.setBorder(javax.swing.BorderFactory.createLineBorder(java.awt.Color.GRAY)); // Crea un bordo nero intorno al menu
{
JMenuItem menuTaglia = new JMenuItem(mappaAzioni.get(DefaultEditorKit.cutAction));
menuTaglia.setText("Taglia");
menuA.add(menuTaglia);
JMenuItem menuCopia = new JMenuItem(mappaAzioni.get(DefaultEditorKit.copyAction));
menuCopia.setText("Copia");
menuA.add(menuCopia);
JMenuItem menuIncolla = new JMenuItem(mappaAzioni.get(DefaultEditorKit.pasteAction));
menuIncolla.setText("Incolla");
menuA.add(menuIncolla);
menuA.addSeparator();
JMenuItem menuSelezionaTutto = new JMenuItem(mappaAzioni.get(DefaultEditorKit.selectAllAction));
menuSelezionaTutto.setText("Seleziona tutto");
menuA.add(menuSelezionaTutto);
}
txtA.setComponentPopupMenu(menuA);
}
JScrollPane scrollA = new JScrollPane(txtA);
txtAnteprima = new JTextArea("123 456 789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n000 111 .,' abcdefghijklmnopqrstuvwxyz", 2, 39);
txtAnteprima.setFont(font);
txtAnteprima.setEditable(false);
txtAnteprima.setAutoscrolls(true);
txtAnteprima.setTabSize(2);
txtAnteprima.setLineWrap(true);
txtAnteprima.setWrapStyleWord(true);
/************************************************
* Posizionamento dei componenti nella finestra *
************************************************/
JTabbedPane pannelloTab = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.WRAP_TAB_LAYOUT);
pannelloTab.setBorder(javax.swing.BorderFactory.createEmptyBorder(1, 1, 1, 1)); // Elimina l'artefatto grafico con un artefatto grafico. ESTIQAATZI.
this.add(pannelloTab);
JPanel pnlTabPrincipale = new JPanel(new BorderLayout());
pannelloTab.addTab("Codifica", pnlTabPrincipale);
JPanel pnlGenerale = new JPanel(new BorderLayout()); // Pannello generale: comandi e barra di avanzamento
pnlTabPrincipale.add(pnlGenerale, BorderLayout.CENTER);
// Barra di avanzamento
pnlTabPrincipale.add(progress, BorderLayout.SOUTH);
// Aree di testo
JPanel pnlAreeTesto = new JPanel(new GridLayout(1, 2));
pnlAreeTesto.add(scrollDa);
pnlAreeTesto.add(scrollA);
pnlGenerale.add(pnlAreeTesto, BorderLayout.CENTER);
// Pannello dei controlli
JPanel pnlControlli = new JPanel(new BorderLayout());
pnlGenerale.add(pnlControlli, BorderLayout.SOUTH);
// Controlli orientati a sinistra
{
JPanel pnlComandi = new JPanel(new FlowLayout());
pnlComandi.add(btnConverti);
pnlComandi.add(new JLabel("da"));
pnlComandi.add(cbbDa);
pnlComandi.add(new JLabel("a"));
pnlComandi.add(cbbA);
pnlControlli.add(pnlComandi, BorderLayout.WEST);
}
// Controlli orientati a destra
{
JPanel pnlComandi = new JPanel(new FlowLayout(FlowLayout.RIGHT));
pnlComandi.add(btnInverti);
pnlComandi.add(btnEsci);
pnlControlli.add(pnlComandi, BorderLayout.EAST);
}
/******************************************
* Posiziona i componenti nel secondo Tab *
******************************************/
JPanel pnlTabOpzioni = new JPanel(new BorderLayout());
pannelloTab.addTab("Opzioni", pnlTabOpzioni);
JPanel pnlTabOpzioniSuperiore = new JPanel();
pnlTabOpzioniSuperiore.setLayout(new BoxLayout(pnlTabOpzioniSuperiore, BoxLayout.Y_AXIS));
{
JPanel pnlTmp = new JPanel(new FlowLayout(FlowLayout.LEFT)); // Pannello di convenienza: serve a contenere le dimensioni del pannello pnlTabOpzioni; il layout allinea i componenti a sinistra
pnlTmp.add(pnlTabOpzioniSuperiore);
pnlTabOpzioni.add(pnlTmp, BorderLayout.NORTH);
//pannelloTab.addTab("Opzioni", pnlTmp);
}
// Scelta del tema
{
JPanel pnlTema = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlTema.add(new JLabel("Tema grafico"));
pnlTema.add(cbbTemi);
pnlTabOpzioniSuperiore.add(pnlTema);
}
// Scelta del font
{
JPanel pnlFont = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlFont.add(new JLabel("Font")); // Nome del font
pnlFont.add(cbbFont);
pnlFont.add(ckbGrassetto); // Stile grassetto
pnlFont.add(ckbCorsivo); // Stile corsivo
pnlFont.add(spnDimensioneFont); // Dimensione del font
pnlTabOpzioniSuperiore.add(pnlFont);
}
// Area per l'anteprima del testo
pnlTabOpzioni.add(txtAnteprima, BorderLayout.CENTER);
/*****************************************************
* Crea il tab con le informazioni dell'applicazione *
*****************************************************/
JPanel pnlTabInfo = new JPanel(new BorderLayout());
pannelloTab.addTab("Info", pnlTabInfo);
{
JPanel pnlCentrato = new JPanel(); // Pannello centrale
pnlCentrato.setLayout(new BoxLayout(pnlCentrato, BoxLayout.Y_AXIS));
JLabel lblLogoProgramma = new JLabel(creaIcona("img/128/binary.png"), JLabel.CENTER);
JPanel pnlLogo = new JPanel();
pnlLogo.add(lblLogoProgramma);
JLabel lblTitolo = new JLabel("Sistemi Di Numerazione", JLabel.CENTER);
lblTitolo.setFont(lblTitolo.getFont().deriveFont(Font.BOLD)); // Applica lo stile grassetto
JPanel pnlTitolo = new JPanel();
pnlTitolo.add(lblTitolo);
JLabel lblVersione = new JLabel("1.5", JLabel.CENTER);
JPanel pnlVersione = new JPanel();
pnlVersione.add(lblVersione);
JLabel lblDescrizione_1 = new JLabel("Il programma permette di convertire numeri interi positivi tra basi numeriche differenti.", JLabel.CENTER);
JPanel pnlDescrizione_1 = new JPanel();
pnlDescrizione_1.add(lblDescrizione_1);
JLabel lblDescrizione_2 = new JLabel("È possibile codificare il testo in ASCII rappresentato in diverse basi numeriche.", JLabel.CENTER);
JPanel pnlDescrizione_2 = new JPanel();
pnlDescrizione_2.add(lblDescrizione_2);
URLJLabel lblWebPage = new URLJLabel("www.antoniobianco.altervista.org/java/SistemiDiNumerazione", JLabel.CENTER, "http://www.antoniobianco.altervista.org/java/SistemiDiNumerazione/");
JPanel pnlWebPage = new JPanel();
pnlWebPage.add(lblWebPage);
JLabel lblDiritti = new JLabel("Copyleft © 2011-2012 Antonio Bianco", JLabel.CENTER);
JPanel pnlDiritti = new JPanel();
pnlDiritti.add(lblDiritti);
URLJLabel lblLicenza = new URLJLabel(creaIcona("img/128/gplv3.png"), JLabel.CENTER, "http://www.gnu.org/licenses/gpl.html");
JPanel pnlLicenza = new JPanel();
pnlLicenza.add(lblLicenza);
pnlCentrato.add(pnlLogo);
pnlCentrato.add(pnlTitolo);
pnlCentrato.add(pnlVersione);
pnlCentrato.add(pnlDescrizione_1);
pnlCentrato.add(pnlDescrizione_2);
pnlCentrato.add(pnlWebPage);
pnlCentrato.add(pnlDiritti);
pnlCentrato.add(pnlLicenza);
JPanel pnlCentratoPack = new JPanel(); // Pannello di convenienza per contenere le dimensioni
pnlCentratoPack.add(pnlCentrato);
pnlTabInfo.add(pnlCentratoPack, BorderLayout.CENTER);
}
Dimension dimensioni = Toolkit.getDefaultToolkit().getScreenSize();
setSize((int)(dimensioni.getWidth()/100*50), (int)(dimensioni.getHeight()/100*50));
setLocation((int)(dimensioni.getWidth()/2-getWidth()/2), (int)(dimensioni.getHeight()/2-getHeight()/2));
this.setVisible(true);
txtDa.requestFocus(); // Setta il focus alla prima area di testo
}
/**
* Avvia o ferma la conversione
*/
private void converti()
{
conversione= !conversione;
}
public void run()
{
while(true) // Mantiene il thread attivo
{
try
{
Thread.sleep(50);
}
catch(Exception e){}
if(conversione) // Si muove solo quando inizia una conversione (es.: fronte di salita)
{
// Avviso sui numeri in base 1
if (cbbA.getSelectedIndex()==1)
{
if (JOptionPane.YES_OPTION!=JOptionPane.showConfirmDialog(this,"ATTENZIONE!\n\nL'usoimpropriopuòesserenocivotenerefuoridallaportatadeinabbini\nVuoi continuare ugualmente?", this.getTitle(), JOptionPane.YES_NO_OPTION))
{
conversione = false;
}
//System.out.println("ATTENZIONE! L'usoimpropriopuòesserenocivotenerefuoridallaportatadeinabbini.");
}
// Preparazione alla conversione: viene eseguito una sola volta
txtDa.setEditable(false);
txtA.setEditable(false);
btnConverti.setText("Stop");
btnConverti.setToolTipText("Ferma la conversione");
btnInverti.setEnabled(false);
btnEsci.setEnabled(false);
cbbDa.setEnabled(false);
cbbA.setEnabled(false);
progress.setIndeterminate(true);
// Cicli di conversione
while(conversione)
{
try
{
if (txtDa.getText().length()>0) // Converti solo se la lunghezza della stringa da convertire è maggiore di zero
{
int base_da = cbbDa.getSelectedIndex();
int base_a = cbbA.getSelectedIndex();
/**
* Converti per:
* TESTO → TESTO: prendi per il culo
* TESTO → NUMERO: converte ciascun carattere in ascii al valore specificato nella base
* NUMERO → TESTO: codifica ogni numero nel carattere corrispondente
* NUMERO → NUMERO: facile
*/
txtA.setText("");
if ((base_da==0)&&(base_a==0)) // TESTO → TESTO: prendi per il culo
{
JOptionPane.showMessageDialog(this, "GUARDA...\nIo te lo scrivo lo stesso il risultato,\nMa tu promettimi di fare qualcosa per quei neuroni diversamente grigi che hai, OK?", this.getTitle(), JOptionPane.INFORMATION_MESSAGE);
txtA.setText(txtDa.getText());
progress.setIndeterminate(false);
}
else if ((base_da==0)&&(base_a>0)) // TESTO → NUMERO: converte ciascun carattere in ascii al valore specificato nella base
{
String testo = txtDa.getText();
String risultato = "";
progress.setIndeterminate(false);
progress.setMaximum(testo.length());
for (int i=0; (i<testo.length())&&(conversione); i++)
{
progress.setValue(i);
if (base_a==1)
{
// converte in base 10 e poi in base 1
int intero = Integer.parseInt(Conversioni.charToBase(testo.charAt(i), 10));
long avanzamento = 0;
long avanzamentoDaVisualizzare = 0;
int stepAvanzamento = 50;
for (int j=0; (j<=intero)&&(conversione); j++) // Per il ciclo alta tensione..
{
risultato += "0";
avanzamento++;
if (avanzamento>=avanzamentoDaVisualizzare)
{
txtA.setText(avanzamento + "/" + intero);
avanzamentoDaVisualizzare = avanzamento + stepAvanzamento;
if (avanzamentoDaVisualizzare>intero) avanzamentoDaVisualizzare=intero;
}
Thread.sleep(1);
}
if (conversione) // Se è finito bene
{
risultato += " ";
}
else // Se è stato interrotto
{
risultato = "";
JOptionPane.showMessageDialog(this, "La conversione è stata annullata dall'utente.", this.getTitle(), JOptionPane.INFORMATION_MESSAGE);
}
}
else
{
risultato += Conversioni.charToBase(testo.charAt(i), base_a) + " ";
}
Thread.sleep(1);
}
risultato = risultato.trim(); // Toglie gli spazi iniziali e finali
txtA.setText(risultato);
progress.setValue(0);
}
else if ((base_da>0)&&(base_a==0)) // NUMERO → TESTO: codifica ogni numero nel carattere corrispondente
{
String[] numeri = txtDa.getText().split(" ");
String risultato = "";
progress.setIndeterminate(false);
progress.setMaximum(numeri.length);
for (int i=0; (i<numeri.length)&&(conversione); i++)
{
String tmp = Conversioni.baseToDec(numeri[i], base_da);
if (tmp.startsWith(Conversioni.ERRORE))
{
conversione = false;
JOptionPane.showMessageDialog(this, "Il numero da convertire non è espresso in base " + base_da, this.getTitle(), JOptionPane.WARNING_MESSAGE);
}
else
{
int ascii = new Integer(tmp);
char[] carattere = Character.toChars(ascii);
risultato += carattere[0] + "";
progress.setValue(i);
}
Thread.sleep(1);
}
risultato = risultato.trim(); // Toglie gli spazi iniziali e finali
txtA.setText(risultato);
progress.setValue(0);
}
else if ((base_da>0)&&(base_a>0)) // NUMERO → NUMERO: facile
{
String[] numeri = txtDa.getText().split(" ");
String risultato = "";
progress.setIndeterminate(false);
progress.setMaximum(numeri.length);
for (int i=0; (i<numeri.length)&&(conversione); i++)
{
String tmp = Conversioni.baseToDec(numeri[i], base_da);
if (tmp.startsWith(Conversioni.ERRORE))
{
conversione = false;
JOptionPane.showMessageDialog(this, "Il numero da convertire non è espresso in base " + base_da, this.getTitle(), JOptionPane.WARNING_MESSAGE);
}
else
{
progress.setValue(i);
if (base_a==1)
{
Long intero = new Long(tmp); // Istruzione con pericolo di overflow
if (intero > Conversioni.MAX_DEC)
{
conversione = false;
JOptionPane.showMessageDialog(this, "Overflow:\nIl numero da convertire è maggiore di " + Conversioni.MAX_DEC, this.getTitle(), JOptionPane.WARNING_MESSAGE);
}
else
{
long avanzamento = 0;
long avanzamentoDaVisualizzare = 0;
int stepAvanzamento = 50;
for (int j=0; (j<=intero)&&(conversione); j++) // Per il ciclo alta tensione...
{
risultato += "0";
avanzamento++;
if (avanzamento>=avanzamentoDaVisualizzare)
{
txtA.setText(avanzamento + "/" + intero);
avanzamentoDaVisualizzare = avanzamento + stepAvanzamento;
if (avanzamentoDaVisualizzare>intero) avanzamentoDaVisualizzare=intero;
}
Thread.sleep(1);
}
if (conversione) // Se è finito bene
{
risultato += " ";
}
else // Se è stato interrotto
{
risultato = "";
JOptionPane.showMessageDialog(this, "La conversione è stata annullata dall'utente.", this.getTitle(), JOptionPane.INFORMATION_MESSAGE);
}
}
}
else
{
risultato += Conversioni.decToBase(tmp, base_a) + " ";
}
}
Thread.sleep(1);
}
risultato = risultato.trim(); // Toglie gli spazi iniziali e finali
txtA.setText(risultato);
progress.setValue(0);
}
}
else
{
JOptionPane.showMessageDialog(this, "Non credi che manchi qualcosa?", this.getTitle(), JOptionPane.INFORMATION_MESSAGE);
txtDa.setText("Inserisci in questa casella il testo o il numero da convertire.");
}
conversione = false;
}
catch(Exception e)
{
// Qualsiasi errore di conversione
conversione = false;
}
}
// Fine della conversione (es.: fronte di discesa)
progress.setIndeterminate(false);
txtDa.setEditable(true);
txtA.setEditable(true);
btnConverti.setText("Converti");
btnConverti.setToolTipText("Converte nella base specificata");
btnInverti.setEnabled(true);
btnEsci.setEnabled(true);
cbbDa.setEnabled(true);
cbbA.setEnabled(true);
}
}
}
/**
* Aggiorna il font delle caselle di testo
*/
private void aggiornaFont()
{
Font font = new Font(Opzioni.FONT_NAME, Opzioni.FONT_STILE, Opzioni.FONT_SIZE);
txtDa.setFont(font);
txtA.setFont(font);
txtAnteprima.setFont(font);
}
/**
* Esce dal programma
*/
private void esci()
{
if (conversione) return;
if (JOptionPane.YES_OPTION==JOptionPane.showConfirmDialog(this,"Vuoi uscire dall'inutility?", this.getTitle(), JOptionPane.YES_NO_OPTION))
{
SistemiDiNumerazione.salvaOpzioni();
System.exit(0);
}
}
/**
* Crea un'icona generica per qualsiasi componente
*/
private ImageIcon creaIcona(String path)
{
URL imgURL = Finestra.class.getResource(path);
if (imgURL != null)
{
return new ImageIcon(imgURL);
}
else
{
System.err.println("Impossibile trovare l'immagine " + path);
return null;
}
}
/**
* Imposta l'icona per la finestra corrente
*/
private void impostaIcona(String path)
{
URL imgURL = Finestra.class.getResource(path);
if (imgURL != null)
{
setIconImage(Toolkit.getDefaultToolkit().getImage(imgURL));
}
else
{
System.err.println("Impossibile trovare " + imgURL.getPath() + "\nFile: " + imgURL.getFile());
}
}
/**
* Ascoltatore dei bottoni
*/
public void actionPerformed(ActionEvent e)
{
if (e.getSource().equals((Object)btnConverti))
{
converti();
}
else if (e.getSource().equals((Object)btnInverti))
{
String tmp = txtDa.getText();
txtDa.setText(txtA.getText());
txtA.setText(tmp);
int indice = cbbDa.getSelectedIndex();
cbbDa.setSelectedIndex(cbbA.getSelectedIndex());
cbbA.setSelectedIndex(indice);
}
else if (e.getSource().equals((Object)cbbDa))
{
//int scelta = cbbDa.getSelectedIndex();
//if (scelta==1)
//{
// Barra di stato con Warning
//JOptionPane.showMessageDialog(this, "ATTENZIONE!\n\nL'usoimpropriopuòesserenocivotenerefuoridallaportatadeinabbini", this.getTitle(), JOptionPane.WARNING_MESSAGE);
//}
}
else if (e.getSource().equals((Object)cbbA))
{
//int scelta = cbbA.getSelectedIndex();
//if (scelta==1)
//{
// Barra di stato con Warning
//JOptionPane.showMessageDialog(this, "ATTENZIONE!\n\nL'usoimpropriopuòesserenocivotenerefuoridallaportatadeinabbini", this.getTitle(), JOptionPane.WARNING_MESSAGE);
//}
}
else if (e.getSource().equals((Object)cbbTemi))
{
// Aggiorna il tema corrente
Opzioni.TEMA_CORRENTE = (String)cbbTemi.getSelectedItem();
SistemiDiNumerazione.cambiaTema();
SwingUtilities.updateComponentTreeUI(menuDa); // Aggiorna il tema dei menu
SwingUtilities.updateComponentTreeUI(menuA);
/*
* bug di Java6: JSpinner perde l'allineamento quando cambia Tema
* CORRETTO
*/
JComponent editor = spnDimensioneFont.getEditor();
if (editor instanceof DefaultEditor) ((DefaultEditor)editor).getTextField().setHorizontalAlignment(JTextField.RIGHT); // Allineamento del testo a destra
}
else if (e.getSource().equals((Object)cbbFont))
{
// Aggiorna il font corrente
Opzioni.FONT_NAME = (String)cbbFont.getSelectedItem();
cbbFont.setToolTipText(Opzioni.FONT_NAME);
aggiornaFont();
}
else if ((e.getSource().equals((Object)ckbGrassetto))||(e.getSource().equals((Object)ckbCorsivo)))
{
// Aggiorna lo stile del font corrente
Opzioni.FONT_STILE = 0;
if (ckbGrassetto.isSelected())
{
Opzioni.FONT_STILE = Font.BOLD;
}
if (ckbCorsivo.isSelected())
{
Opzioni.FONT_STILE += Font.ITALIC;
}
aggiornaFont();
}
else if (e.getSource().equals((Object)btnEsci))
{
esci();
}
else
{
System.out.println("DEBUG: Nessun'azione associata al componente.");
}
}
/**
* Ascoltatore del JSpinner
*/
public void stateChanged(ChangeEvent e)
{
if (e.getSource().equals((Object)spnDimensioneFont))
{
try
{
Opzioni.FONT_SIZE = Integer.parseInt((String)spnDimensioneFont.getValue());
aggiornaFont();
}
catch(Exception exc){}
}
}
/**
* Ascoltatore della finestra
*/
public void windowActivated(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowClosing(WindowEvent e)
{
esci();
}
public void windowDeactivated(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
}
Raw
Opzioni.java
/**
* Questa classe conserva le informazioni che devono essere gestite da più classi
*
* Autore: Antonio Bianco
*/
import java.awt.Font;
import java.util.HashMap;
import java.util.Vector;
public class Opzioni
{
// Istanza di variabili
public static Vector<String> TEMI = new Vector<String>(); // Elenco dei temi disponibili
public static HashMap<String, String> MAP_TEMI = new HashMap<String, String>(); // Hash Map dei temi(chiavi) e dei relativi nomi di classe(valori)
public static Vector<String> LISTA_FONT = new Vector<String>(); // Lista dei font installati nel sistema
public static boolean FONT_PERSONALIZZATO = false; // Specifica se il font che si sta utilizzando è personalizzato o predefinito
// Opzioni da caricare/salvare
public static String TEMA_CORRENTE = ""; // Tema corrente
public static String FONT_NAME = ""; // Font selezionato
public static int FONT_STILE = 0; // Stile del font selezionato
public static int FONT_SIZE = 0; // Altezza del font selezionato
// Opzioni di default
public static String TEMA_DEFAULT = ""; // Tema predefinito di sistema
public static String FONT_DEFAULT_NAME = Font.MONOSPACED; // Font predefinito
public static int FONT_DEFAULT_STILE = Font.PLAIN; // Stile del font predefinito
public static int FONT_DEFAULT_SIZE = 12; // Altezza del font predefinito
/**
* Costruttore della classe
*/
public Opzioni()
{
// Assolutamente NIENTE
}
}
Raw
SistemiDiNumerazione.java
/**
* Avvia il programma
*
* Autore: Antonio Bianco
*/
import java.awt.Font;
import java.awt.GraphicsEnvironment;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.net.URL;
import javax.swing.JFrame;
import javax.swing.UIManager;
import javax.swing.UIManager.LookAndFeelInfo;
import javax.swing.SwingUtilities;
import java.util.HashMap;
public class SistemiDiNumerazione
{
/*
* Avvia l'applicazione con il tema grafico scelto dell'utente
*/
public static String ABS_PATH;
final static String OPZIONI = ".SistemiDiNumerazione.txt";
private static Finestra gui;
public static void main(String args[])
{
ABS_PATH = getAbsolutePath(); // Definisce il percorso assoluto dell'applicazione
boolean argomento = false;
leggiOpzioni();
// Applica il tema scelto
// Carico la lista dei temi, vedo qual è il tema predefinito e nel frattempo vedo se il tema corrente è valido
boolean temaCorrenteValido = false;
try
{
String classeTemaPredefinito = UIManager.getSystemLookAndFeelClassName();
for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels())
{
// Carico la lista dei temi disponibili
Opzioni.MAP_TEMI.put(info.getName(), info.getClassName());
Opzioni.TEMI.add(info.getName());
// Identifico il tema predefinito
if (classeTemaPredefinito.equals(info.getClassName())) Opzioni.TEMA_DEFAULT = info.getName();
// Vedo se il tema corrente è valido
if (Opzioni.TEMA_CORRENTE.equals(info.getName())) temaCorrenteValido = true;
}
if (!temaCorrenteValido) Opzioni.TEMA_CORRENTE = Opzioni.TEMA_DEFAULT; // Se il tema corrente non è valido, seleziona il tema di default
UIManager.setLookAndFeel(Opzioni.MAP_TEMI.get(Opzioni.TEMA_CORRENTE)); // Applico il tema valido
}
catch (Exception e)
{
System.err.println("Ecchitelo!");
}
// Elenco i font di sistema
String[] elencoFont = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
for (int i=0; i<elencoFont.length; i++)
{
Opzioni.LISTA_FONT.add(elencoFont[i]);
}
// Se il font delle opzioni non è stato trovato, usa il font di default: Font.MONOSPACED
if (!Opzioni.LISTA_FONT.contains(Opzioni.FONT_NAME)) Opzioni.FONT_NAME = Opzioni.FONT_DEFAULT_NAME;
// Se lo stile memorizzato nelle opzioni non è valido, prende lo stile di default: Font.PLAIN
if ((Opzioni.FONT_STILE!=Font.PLAIN)&&(Opzioni.FONT_STILE!=Font.BOLD)&&(Opzioni.FONT_STILE!=Font.ITALIC)&&(Opzioni.FONT_STILE!=Font.BOLD+Font.ITALIC)) Opzioni.FONT_STILE = Font.PLAIN;
// se la dimensione del font memorizzato nelle opzioni non è valido, prende la dimensione di default: 12
if (Opzioni.FONT_SIZE==0) Opzioni.FONT_SIZE = Opzioni.FONT_DEFAULT_SIZE;
// Visualizza la finestra del programma
//JFrame.setDefaultLookAndFeelDecorated(true); // DEBUG: Funziona solo su Metal. Gli altri sono troppo checche.
gui = new Finestra();
new Thread(gui).start();
}
/**
* Legge il tema salvato nel file delle opzioni.
* Ritorna false se il file è corrotto o inesistente
*/
private static void leggiOpzioni()
{
if (new File(OPZIONI).exists())
{
// Il file esiste
// Si sceglie il tema salvato
try
{
FileReader streamOpzioni = new FileReader(OPZIONI);
BufferedReader bufferOpzioni = new BufferedReader(streamOpzioni);
Opzioni.TEMA_CORRENTE = bufferOpzioni.readLine();
Opzioni.FONT_NAME = bufferOpzioni.readLine();
Opzioni.FONT_STILE = Integer.parseInt(bufferOpzioni.readLine());
Opzioni.FONT_SIZE = Integer.parseInt(bufferOpzioni.readLine());
bufferOpzioni.close();
streamOpzioni.close();
}
catch(Exception e){}
}
}
/**
* Salva le opzioni nel file
*/
public static void salvaOpzioni()
{
try
{
FileWriter fileOpzioni = new FileWriter(OPZIONI);
PrintWriter fileOut = new PrintWriter(fileOpzioni);
fileOut.println(Opzioni.TEMA_CORRENTE);
fileOut.println(Opzioni.FONT_NAME);
fileOut.println(Opzioni.FONT_STILE + "");
fileOut.println(Opzioni.FONT_SIZE + "");
fileOut.close();
fileOpzioni.close();
}
catch(Exception e){}
}
/**
* Ritorna il percorso assoluto dell'applicazione
*/
private static String getAbsolutePath()
{
URL fileURL = SistemiDiNumerazione.class.getResource("/");
if (fileURL == null)
{
return null;
}
else
{
return fileURL.getPath();
}
}
/**
* Cambia il tema grafico in runtime
*/
public static void cambiaTema()
{
try
{
UIManager.setLookAndFeel(Opzioni.MAP_TEMI.get(Opzioni.TEMA_CORRENTE));
SwingUtilities.updateComponentTreeUI(gui);
}
catch (Exception e)
{
System.err.println(e.getMessage());
}
}
}
Raw
URLJLabel.java
/**
* JLabel cliccabile con URL
*
* Autore: Antonio Bianco
* Copyright (c) 2012
*/
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Desktop;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.font.TextAttribute;
import java.net.URI;
import java.util.Hashtable;
import java.util.Map;
import javax.swing.Icon;
import javax.swing.JLabel;
public class URLJLabel extends JLabel implements MouseListener
{
private String url;
/**
* Crea l'istanza di una URLJLabel senza immagine e nessun testo.
*/
public URLJLabel()
{
super();
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando l'immagine.
*/
public URLJLabel(Icon image)
{
super(image);
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando l'immagine e l'url.
*/
public URLJLabel(Icon image, String url)
{
super(image);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando l'immagine e l'allineamento orizzontale.
*/
public URLJLabel(Icon image, int horizontalAlignment)
{
super(image, horizontalAlignment);
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando l'immagine, l'allineamento orizzontale e l'url.
*/
public URLJLabel(Icon image, int horizontalAlignment, String url)
{
super(image, horizontalAlignment);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando il testo.
*/
public URLJLabel(String text)
{
super(text);
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando il testo e l'url.
*/
public URLJLabel(String text, String url)
{
super(text);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando il testo, l'immagine e l'allineamento orizzontale.
*/
public URLJLabel(String text, Icon icon, int horizontalAlignment)
{
super(text, icon, horizontalAlignment);
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando il testo, l'immagine e l'url.
*/
public URLJLabel(String text, Icon icon, String url)
{
super(icon);
setText(text);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/**
* Crea l'istanza di una URLJLabel specificando il testo, l'immagine, l'allineamento orizzontale e l'url.
*/
public URLJLabel(String text, Icon icon, int horizontalAlignment, String url)
{
super(text, icon, horizontalAlignment);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/**
* Crea l'istanda di una URLJlabel specificando il testo e l'allineamento orizzontale.
*/
public URLJLabel(String text, int horizontalAlignment)
{
super(text, horizontalAlignment);
setProprieta();
addMouseListener(this);
}
/**
* Crea l'istanda di una URLJlabel specificando il testo, l'allineamento orizzontale e l'url.
*/
public URLJLabel(String text, int horizontalAlignment, String url)
{
super(text, horizontalAlignment);
setProprieta();
setUrl(url);
addMouseListener(this);
}
/** Imposta le proprietà del componente */
private void setProprieta()
{
setForeground(Color.BLUE); // Testo blu
setCursor(new Cursor(Cursor.HAND_CURSOR)); // Cursore mano
Map<TextAttribute, Object> map = new Hashtable<TextAttribute, Object>();
map.put(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON);
setFont(getFont().deriveFont(map));
}
/**
* Ritorna l'url
*/
public String getUrl()
{
return url;
}
/**
* Imposta l'url
*/
public void setUrl(String url)
{
this.url = url;
setToolTipText(url);
}
/**
* Avvia l'url come se il componente avesse ricevuto il click. Ritorna false se si verifica un errore.
*/
public boolean click()
{
boolean errore = false;
if (Desktop.isDesktopSupported())
{
try
{
errore = true; // Controllo ridondante dell'errore
Desktop.getDesktop().browse(new URI(url)); // Avvia l'url
setForeground(Color.BLUE.darker()); // Testo blu scuro
errore = false;
}
catch(Exception e)
{
errore = true;
}
}
return errore;
}
/** Invoked when the mouse button has been clicked (pressed and released) on a component. */
public void mouseClicked(MouseEvent e)
{
click();
}
/** Invoked when the mouse enters a component. */
public void mouseEntered(MouseEvent e) {}
/** Invoked when the mouse exits a component. */
public void mouseExited(MouseEvent e) {}
/** Invoked when a mouse button has been pressed on a component. */
public void mousePressed(MouseEvent e) {}
/** Invoked when a mouse button has been released on a component. */
public void mouseReleased(MouseEvent e) {}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment