Alegerea culorii

În multe aplicații, la proiectarea interfeței utilizator grafice este necesar să se impună culorile de fond și de primplan ale diferitelor componente, folosind metodele clasei Component
    public void setBackground(Color color) - pentru culoarea de fond;
    public void setForeground(Color color) - pentru culoarea de prim-plan (a textului).

Pentru reprezentarea și manipularea informației despre culoare se folosește clasa java.awt.Color. Cea mai simplă utilizare a acestei clase este utilizarea culorilor predefinite, pe care le conține sub forma de câmpuri statice.

De exemplu, culoarea albastru este reprezentată prin câmpul static Color.blue, iar culoarea galben prin Color.yellow. În consecință, dacă dorim  să punem componentei comp  culoarea de fond albastru și culoarea de primplan galben, vom folosi instrucțiunile:
    comp.setBackground(Color.blue);
    comp.setForeground(Color.yellow);
Pentru a afla toate culorile predefinite și celelalte specificații privind clasa Color trimitem cititorii la documentația Java API. Culorile predefinite sunt folosite și în exemplul care urmează.
 
Exemplu
În fișierul Culori.java se dă un exemplu de aplicație, în care se demonstrează utilizarea culorilor predefinite din clasa java.awt.Color.

Fereastra aplicației conține o listă cu denumirile culorilor predefinite din clasa Color și un panou pe care se afișează culorile respective, prin setarea corespunzătoare a culorii de fond a panoului. Când se selectează o culoare din listă, se observa imediat modificarea corespunzătoare a culorii panoului. În acest scop, în program au fost folosite două tablouri:
   numeCulori - este un tablou de șiruri (String[]) care conțin numele culorilor;
   tablouCulori - este un tablou de instanțe ale clasei Color, care conține toate culorile predefinite din aceasta clasă.
   Lista de culori listaCulori din clasa JList este construită pe baza tabloului numeCulori și deci conține ca articole numele culorilor (denumirile puteau fi date în limba română, dar am preferat ca cititorii să se familiarizeze cu cele existente în clasa Color).

Când se selectează un articol din listă, se generează un ListSelectionEvent. Pentru ascultarea lui s-a creeat clasa AscultaLista. În metoda valueChanged a acestei clase, se determină indicele articolului care a fost selectat și se setează drept culoare de fond a panoului culoarea cu același indice din tablouCulori.
 
/* Alegerea culorilor folosind obiectele de culoare predefinite
   din clasa Color
*/

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

class Culori { 
 static AF af=new AF();
 static IUG iug=new IUG("Alegerea culorii din lista");

 /* clasa imbricata pentru interfata utilizator grafica */
 static class IUG extends JFrame {
  JPanel panouCuloare; // panoul pe care se prezinta culoarea
  String[] numeCulori={"black", "darkGray", "gray", 
   "lightGray", "white", "blue", "cyan", "green", "orange",
   "yellow", "red", "pink", "magenta"};
  Color[] tablouCulori={Color.black, Color.darkGray, Color.gray,
   Color.lightGray, Color.white, Color.blue, Color.cyan, Color.green,
   Color.orange, Color.yellow, Color.red, Color.pink, Color.magenta};
  JList listaCulori;

  IUG(String titlu) { // constructorul clasei IUG
   super(titlu);
   setSize(250, 200);
   setLocation(100, 50);
   Container cp=getContentPane();
   addWindowListener(af);  // adaugarea ascultatorului de fereastra
   panouCuloare=new JPanel(); // crearea panoului pentru culoare
   cp.add(panouCuloare, BorderLayout.CENTER);

   Color[] tablouCulori={Color.black, Color.darkGray, Color.white};
   listaCulori=new JList(numeCulori);
   listaCulori.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
   listaCulori.addListSelectionListener(new AscultLista());
   JScrollPane panouCulori=new JScrollPane(listaCulori);
   cp.add(panouCulori, BorderLayout.WEST);

   setVisible(true);
  }

 } 
 

 /* Clasa ascultatoare de fereastra */ 
 static class AF extends WindowAdapter {
  public void windowClosing(WindowEvent e) {
   System.exit(0); // incheierea executarii aplicatiei
  }
 }

 /* Clasa ascultatoare a listei de culori */
 static class AscultLista implements ListSelectionListener {
  public void valueChanged(ListSelectionEvent e) {
   int indiceCuloare=iug.listaCulori.getSelectedIndex();
   iug.panouCuloare.setBackground(iug.tablouCulori[indiceCuloare]);
  }
 }

 /* Metoda principala a aplicatiei */
 public static void main(String args[]) {
 }
}

Clasa Color


Clasa Color încapsulează informațiile despre culoare. În Java AWT se folosește modelul de culori RGB (engleză: red, green, blue) în care fiecare culoare este considerată ca fiind compusă din trei culori fundamentale: roșu, verde și albastru. În consecință, culoarea este dată prin trei numere cuprinse în intervalul [0, 255], reprezentând ponderile celor trei culori fundamentale. În figura de mai jos este reprezentată schema de combinare a acestor trei culori fundamentale.

Prin modificarea ponderilor celor trei culori se pot obține, în principiu, toate culorile posibile, de la negru [r=0,g=0,b=0] la alb [r=255,g=255,b=255]. Dacă ponderile celor trei culori sunt egale, se obțin diferite nuanțe de gri. Culoarea galbenă are ponderile [r=255,g=255,b=0], culoarea cyan (azuriu) are ponderile [r=0,g=255,b=255] iar culoarea magenta  are ponderile [r=255,g=0,b=255]. Alte culori: orange: [r=255,g=200,b=0], pink (roz): [r=255,g=175,b=175].
 
Clasa Color conține și un al patrulea câmp, numit alpha, care poate avea, de asemenea, valori întregi în intervalul [0..255] și exprima opacitatea culorii respective. Daca alpha=255, culoarea este complet opaca. Aceasta înseamnă că, dacă o figură cu această culoare se suprapune peste alta, o maschează complet. Dacă alpha=0, culoarea este complet transparentă, deci practic invizibilă. Între aceste valori extreme putem avea diferite opacități intermediare, cuprinse intre 0 si 255.

Culoarea în sistemul RGB poate fi exprimată nu numai printr-o instanță a clasei Color, ci și printr-un număr întreg (de tip int), în care cei patru octeți au, respectiv, valorile componentelor alpha, r, g, b  exprimate în intervalul [0..255]. Componentele sunt plasate astfel: alpha în biții 24..31, r în biții 16..23, g în biții 8..15 și b în biții 0..7.

Clasa Color conține, de asemenea, constructori și metode care suportă sistemele de culori sRBG și HSB. Standardul sRGB definește o variantă standardizată a sistemului RGB, destinată monitoarelor cu tub catodic. În acest sistem, parametrii r, g, b și alpha se exprimă prin numere reale în intervalul [0.0...1.0].
 


 
Sistemul de culori HSB (engleză: Hue, Saturation and Brightness) ofera o descriere a culorilor independentă de sistemul de afișare, folosind următorii trei parametri:
    Nuanța (engleză: Hue) care se exprimă în grade, în intervalul [0..360], unde 0 este rosu, 60 este galben, 120 este verde etc.
    Saturație (engleză: Saturation) este puritatea culorii, exprimată în procente, în intervalul [0..100]. La valoarea 0, nuanța (Hue) nu are semnificatie, iar la valoarea 100 culoarea este pură.
    Strălucire (engleză: Brightness) este exprimată de asemenea în procente, în intervalul [0..100]. Valoarea 0 înseamnă negru (iluminare 0%), deci parametrii Hue și Saturation nu au sens. Valoarea 100 reprezintă strălucirea maximă. Diagrama de mai jos dă o reprezentare a culorilor exprimate în sistemul HSB.

În clasa Color, parametrii Hue, Saturation și Brightness se exprimă prin numere reale (tipul float) în intervalul [0.0 .. 1.0].
Dacă valorile sunt în afara acestui interval, se ia în considerație numai partea fracționara: de exemplu valoarea 2.73 se consideră echivalentă cu 0.73. În aceste condiții, dacă se consideră saturația și strălucirea egale cu 1.0 (100%), valorile parametrului Hue (nuanță) pentru principalele culori sunt:
    red: h=0.0;
    yellow: h=0.6666      (600);
    green: h=0.3333       (1200);
    cyan: h=0.5              (1800);
    blue: h=0.6666         (2400);
    magenta: h=0.8333   (3000)
    Culoarea neagra (black) se obtine punând strălucirea Brightness=0, iar culoarea albă (white) se obține punand saturația Saturation=0 și strălucirea Brightness=1. Dacă se menține saturația la valoarea 0 și se dau strălucirii diferite valori între 0 și 1 se obțin nuanțele de gri.
 


 
Variabile:
Clasa Color conține variabile statice finale (constante) care sunt instanțieri ale clasei pentru diferite culori tipice:
    black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange, pink, red, white yellow.
    Acestea sunt, respectiv, culorile  negru, albastru, azuriu, gri inchis, gri, verde, gri deschis, mov, roz, rosu, alb și galben. De exemplu, culoarea verde va fi reprezentata prin Color.green. Toate aceste culori sunt opace, deci au componenta alpha cu valoarea 255.
 

Constructori:
Clasa Color are mai mulți constructori, dintre care menționăm aici pe cei mai frecvent folosiți:
    public Color(int r, int g, int b) - în care argumentele r,g,b sunt numere întregi în intervalul [0..255], reprezentând ponderile culorilor red, green, blue, iar componenta alpha are implicit valoarea 255;
    public Color(int r, int g, int b, int alpha) - similar cu cel precedent, indicându-se în plus gradul de opacitate alpha, de asemenea în intervalul [0..255];
    public Color(int rgb) - creează o culoare opacă cu parametrii r,g,b dați ultimii trei octeți ai argumentului rgb;
    public Color(int rgba, boolean hasalpha) - creează o culoare pornind de la parametrii alpha,r,g,b împacetați în cei patru octeți ai argumentului rgba. Daca al doilea argument este true, parametrul alpha (bitii 24..31 ai argumentului) este luat în considerație;
    public Color(float r, float g, float b) - creează o culoare opacă în sistemul sRGB, în care r,g,b sunt ponderile culorilor fundamentale în intervalul [0.0...1.0],  iar alpha are valoarea implicită 1.0;
    public Color(float r, float g, float b, float alpha) - creează o culoare în sistemul sRGB, fiind dați toti cei patru parametri.

Metode:
Menționăm aici metodele cel mai frecvent utilizate.

    public int getRed() - întoarce ponderea culorii red (rosu);
    public int getGreen() - întoarce ponderea culorii green(verde);
    public int getBlue() - întoarce ponderea culorii blue(albastru);
    public int getAlpha() - întoarce componenta alpha(opacitatea culorii);
    public Color brighter() - creează o versiune mai luminoasă a acestei culori;
    public Color darker() - creează o versiune mai întunecată a acestei culori;
    public static Color getHSBColor(float h, float s, float b) - creează o instanță a clasei Color (deci în sistemul RGB) pornind de la parametrii h, s și b ai culorii respective, exprimați is sistemul HSB, în intervalul [0.0 ... 1.0];
    public static int HSBtoRGB(float h, float s, float b) - transformă parametrii h,s,b ai culorii exprimate în sistemul HSB prin numere reale în intervalul [0.0 ... 1.0] într-un număr întreg (int), în care cei patru octeți sunt parametrii r,g,b,alpha ai aceleeași culori exprimate în sistemul RGB;

O prezentare mai completă a câmpurilor, constructorilor și metodelor clasei Color este dată în Index.


Exemplul 1:

În fișierul TestRGB.java este dat un exemplu de aplicație, în care se testează compunerea diferitelor culori în sistemul RGB. În partea stângă a ferestrei sunt trei rigle de ajustare (JSlider) pentru cele trei culori fundamentale (roșu, verde, albastru). În dreptul fiecărei rigle există un câmp de text în care se afișează valoarea indicată, în întervalul [0, 255]. În partea dreaptă a ferestrei există un panou (JPanel) a cărui culoare de fond corespunde combinației de culori date de cele trei rigle.
Puteți ajusta culorile și urmări efectul produs.

Exemplul 2:

În fișierul TestHSB.java este dat un exemplu de aplicație în care se testează alegerea culorilor în sistemul HSB. Fereastra se aseamană cu cea din exemplul precedent, dar cele trei rigle servesc pentru ajustarea componentelor HSB: nuanța, saturație și strălucire. Valorile corespunzătoare sunt indicate în câmpurile de text alăturate, ca numere reale în intervalul [0.0, 1.0]. La partea inferioară a ferestrei sunt afișate componentele culorii în sistemul RGB.
 
/* Alegerea culorilor in sistemul HSB (Hue, Saturation, Brightness) */

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

class TestHSB { 
 static AF af=new AF();
 static IUG iug=new IUG("Alegerea culorii in sistemul HSB"+
    " (Hue, Saturation, Brightness)");

 /* clasa imbricata pentru interfata utilizator grafica */
 static class IUG extends JFrame {
  AjustCuloare hue, satur, bright; // rigle de ajustare a culorilor
  Box box1; // caseta riglelor de ajustare
  JPanel panouCuloare; // panoul pe care se prezinta culoarea
  Color culoare; // culoarea panoului panouCuloare
  JLabel culoriRGB; // pentru afisarea culorilor in sistem RGB

  IUG(String titlu) { // constructorul clasei IUG
   super(titlu);
   setSize(500, 200);
   setLocation(100, 50);
   Container cp=getContentPane();
   addWindowListener(af);  // adaugarea ascultatorului de fereastra
   /* Se creeaza caseta cu dispozitive de ajustare */
   box1=Box.createVerticalBox();
   hue=new AjustCuloare("Nuanta      "); // ajustarea nuantei
   box1.add(hue);
   satur=new AjustCuloare("Saturatie  "); // ajustarea saturatiei
   box1.add(satur);
   bright=new AjustCuloare("Stralucire "); // ajustarea stralucirii
   bright.ajustare.setPaintLabels(true);
   box1.add(bright);
   cp.add(box1, BorderLayout.WEST);
   panouCuloare=new JPanel(); // crearea panoului pentru culoare
   cp.add(panouCuloare, BorderLayout.CENTER);
   culoriRGB=new JLabel(); // crearea etichetei cu valori RGB
   cp.add(culoriRGB, BorderLayout.SOUTH);
   puneCuloarea();  // se pune culoarea initiala
   setVisible(true);
  }

  /* Metoda de determinare a culorii RGB */
  void puneCuloarea() {
   culoare=new Color(Color.HSBtoRGB(hue.fval, satur.fval,
     bright.fval)); // conversie din HSB in RGB
   panouCuloare.setBackground(culoare); 
   culoriRGB.setText("Culori RGB -> rosu: "+ 
     culoare.getRed()+"  verde: "+culoare.getGreen()+
     "  albastru: "+culoare.getBlue()); 
  }
 } 

 /* Un "dispozitiv" de ajustare a valorii unei culori */

 static class AjustCuloare extends Box implements ChangeListener {
  JTextField valoare; // camp pentru afisarea valorii HSB
  JSlider ajustare; // rigla de ajustare a valorii
  float fval=1.0f; // valoarea HSB (in intervalul 0,..,1).

  AjustCuloare(String culoare) {
   super(BoxLayout.X_AXIS);
   add(new JLabel(culoare));
   add(Box.createHorizontalGlue());
   ajustare=new JSlider(JSlider.HORIZONTAL, 0, 100,100);
   ajustare.setMajorTickSpacing(20);
   ajustare.setMinorTickSpacing(10);
   ajustare.setPaintTicks(true);
   ajustare.addChangeListener(this);
   add(ajustare);
   add(Box.createHorizontalStrut(5));
   valoare=new JTextField("1.00",4);
   valoare.setHorizontalAlignment(JTextField.RIGHT);
   valoare.setEditable(false);
   valoare.setBackground(Color.white);
   valoare.setMaximumSize(valoare.getMinimumSize());
   add(valoare);
   add(Box.createHorizontalStrut(5));
  }

  /* metoda de ascultare a deplasarii cursorului riglei */
  public void stateChanged(ChangeEvent e) {
   fval=ajustare.getValue()/100.0f; // determinarea valorii reale
      // in intwervalul 0,..1
   valoare.setText((fval+" ").substring(0,4)); // afisarea valorii
   iug.puneCuloarea(); // modificarea culorii panoului
  }
 }
 

 /* Clasa ascultatoare de fereastra */ 
 static class AF extends WindowAdapter {
  public void windowClosing(WindowEvent e) {
   System.exit(0); // incheierea executarii aplicatiei
  }
 }
 

 /* Metoda principala a aplicatiei */
 public static void main(String args[]) {
 }
}

Ajustând valorile prin intermediul riglelor, constatăm următoarele:
  - Dacă strălucirea este 0.0, culoarea obținută este negru, indiferent de valorile celorlalte două componente. Cu cât valoarea strălucirii este mai mare, culoarea obținută este mai deschisă.
  - Dacă saturația este 0.0, valoarea nuanței nu are efect: în acest caz, modificând strălucirea de la 0.0 la 1.0 se obțin diferite nuanțe de gri, de la negru la alb.
  - Dacă saturația și strălucirea au valori diferite de 0.0, culoarea se poate ajusta prin modificarea nuanței. Cu cât saturația este mai mare, nuanța respectivă este mai pronunțată, iar cu cât strălucirea este mai mare, culoarea este mai deschisă.

Alegerea culorii folosind clasa JColorChooser

Pentru a alege culoarea în mod interactiv, în JFC/Swing este prevazută clasa javax.swing.JColorChooser. Instanțele acestei clase sunt panouri de selectare a culorii, care pot fi folosite atât prin încorporarea lor într-o fereastră obișnuită, cât și sub forma unei ferestre de dialog.
 
Pentru a creea o fereastră de dialog, care conține în ea un JColorChooser și întoarce culoarea selectată, în clasa JColorChooser există metoda
    public static JDialog createDialog(Component c,String title, boolean modal, JColorChooser chooserPane, ActionListener okListener, ActionListener cancelListener)
în care:
  - c este componenta beneficiară (owner) a ferestrei de dialog create;
  - title este titlul ferestrei de dialog create;
  - argumentul boolean modal indică dacă fereastra este modală;
  - chooserPane este instanța clasei JColorChooser care se întroduce în fereastra de dialog;
  - okListener si cancelListener sunt ascultătoarele de acțiune care reacționeaza la apăsarea butonului OK, respectiv Cancel al selectorului de culoare.

Folosind un JColorChooser, alegerea culorii se poate face în trei moduri:
  - folosind un tablou de culori, în care fiecare celulă este colorată în altă culoare;
  - în sistemul RGB, folosind trei rigle de ajustare a culorilor fundamentale;
  - în sistemul HSB, selectând culoarea prin alegerea cu mouse-ul a punctului de pe panou care are culoarea potrivita (trei butoane alăturate, notate H, S, B, arată care din cele trei componente se menține constantă, celelalte două fiind date de coordonatele punctului ales pe panou).

Exemplu
În fișierul SelectCulori.java se dă un exemplu de aplicație în care, pentru alegerea culorii unui panou, se folosește o fereastră de dialog, în care se găsește un JColorChooser.
 
/* Alegerea culorilor folosind un JColorChooser */

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

class SelectCulori { 
 static AF af=new AF();
 static AscultDialog ascultDialog=new AscultDialog();
 static AscultButon ascultButon=new AscultButon();
 static IUG iug=new IUG("Alegerea culorii folosind JColorChooser");

 /* clasa imbricata pentru interfata utilizator grafica */
 static class IUG extends JFrame {
  JPanel panouCuloare; // panoul pe care se prezinta culoarea
  JColorChooser selectorCuloare;
  JDialog dialogCuloare;

  IUG(String titlu) { // constructorul clasei IUG
   super(titlu);
   setSize(350, 200);
   setLocation(100, 50);
   Container cp=getContentPane();
   addWindowListener(af);  // adaugarea ascultatorului de fereastra
   panouCuloare=new JPanel(); // crearea panoului pentru culoare
   cp.add(panouCuloare, BorderLayout.CENTER);
   selectorCuloare=new JColorChooser();
   JButton butonCuloare=new JButton("Schimbarea culorii");
   butonCuloare.addActionListener(ascultButon);
   butonCuloare.setToolTipText("Selectarea culorii panoului");
   cp.add(butonCuloare, BorderLayout.SOUTH);
   dialogCuloare=JColorChooser.createDialog(butonCuloare,
    "Alegerea culorii", true, selectorCuloare, ascultDialog,
    ascultDialog); 
   setVisible(true);
  }
 } 

 /* Clasa ascultatoare de fereastra */ 
 static class AF extends WindowAdapter {
  public void windowClosing(WindowEvent e) {
   System.exit(0); // incheierea executarii aplicatiei
  }
 }

 /* Ascultator actiuni fereastra dialog */ 
 static class AscultDialog implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   if(e.getActionCommand().equals("OK"))
    iug.panouCuloare.setBackground(
          iug.selectorCuloare.getColor());
  }
 }

 /* Ascultarea butonului de comanda */
 static class AscultButon implements ActionListener {
  public void actionPerformed(ActionEvent e) {
    iug.dialogCuloare.show();
  }
 }

 /* Metoda principala a aplicatiei */
 public static void main(String args[]) {
 }
}



© Copyright 2000 - Severin BUMBARU, Universitatea "Dunărea de Jos" din Galați