Java Icon in JBuilder

[Verwijderd]

Hallo,

Ik heb het volgende probleem: ik heb een applicatie gebouwd en nu moet ik een ander icoontje weergeven dan het standaard icoontje.

Ik heb het tot nu toe via code geprobeerd. Misschien weet iemand of het ook kan via een optie in JBuilder.

M'n code is als volgt:


Config Bestand

code:

// --------------------------------------------------------------------------
// CLASS : Config
// --------------------------------------------------------------------------

import javax.swing.* ;

/**
 *
 * Configuratiegegevens                    <BR>
 * versie        : 1.7                     <BR><BR>
 *
 * Copyright (c) : J.H. Kalse M.Sc. 2005   <BR>
 */
public class Config
{
    public Config() {
        try {
            jbInit();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static final String LEGE_STRING = "";

  // -------------------------------------------------------------------------
  // DATA : Presentator
  // -------------------------------------------------------------------------

  public static String[] presentatorNaam = {"Francois","Nance"} ;

  // -------------------------------------------------------------------------
  // DATA : Locaties van bestanden
  // -------------------------------------------------------------------------

 /**
  * De huidige map van de applicatie
  */
  public static String huidigeMap            = LEGE_STRING ;

 /**
  * De naam van de submap met geluiden
  */
  public static String naamGeluidMap         = "sound\\" ;

  /**
   * De naam van de submap met afbeeldingen
   */
  public static String naamBeeldMap          = "image\\" ;

  /**
   * Het volledige path naar de map met geluiden
   */
  public static String geluidMap             = LEGE_STRING ;

  /**
   * Het volledige path naar de map met afbeeldingen
   */
  public static String beeldMap              = LEGE_STRING ;

  /**
   *  Het volledige path naar de map met presentator specifieke geluiden
   */
  public static String geluidMapPresentator  = LEGE_STRING ;

  /**
   * Het volledige path naar de map met presentator specifieke afbeeldingen
   */
  public static String beeldMapPresentator   = LEGE_STRING ;


  // -------------------------------------------------------------------------
  // DATA : algemene spelinstellingen
  // -------------------------------------------------------------------------


  public static Presentator presentator         = new Presentator(LEGE_STRING);
  public static final int woordLengte           =   5 ;
  public static final int aantalTeams           =   2 ;
  public static final int aantalTeRadenWoorden  =  12 ;
  public static final int bedragInJackpot       = 200 ;
  public static final int scorePerWoord         =  25 ;
  public static final int scorePerLingo         = 100 ;

  // -------------------------------------------------------------------------
  // DATA : configuratiegegevens woordscherm ( scherm )
  // -------------------------------------------------------------------------

  /**
   * Het aantal regels dat het woordscherm hoog is
   */
  public static final int     woordSchermRegels      = 5 ;

  /**
   * Het formaat van een "lettervlak" op het woordscherm ( in pixels )
   */
  public static final int     woordSchermVlakFormaat = 60 ;

  /**
   *  De naam van de afbeelding die als icoon is op het woordscherm
   */
  public static final String  woordSchermIcoon       = "icon.ico" ;

  /**
   * De titel van het woordscherm
   */
  public static final String  woordSchermTitel       = "Woordscherm" ;

  /**
   * Het lettertype (font) dat voor het woordscherm in gebruik is
   */
  public static final String  woordSchermFont        = "Arial" ;

  /**
   * Het formaat van de letters (in pixels) op het woordscherm
   */
  public static final int     woordSchermFontMaat    = 28 ;

  // -------------------------------------------------------------------------
  // DATA : configuratiegegevens woordscherm ( geluid algemeen )
  // -------------------------------------------------------------------------

  /**
   * Status : woorden op het woordscherm spellen ja/nee
   */
  public static final boolean woordSchermSpellen     = true ;


  // -------------------------------------------------------------------------
  // DATA : configuratie ballencherm ( scherm )
  // -------------------------------------------------------------------------

  public static final int     ballenSchermMaat     =  5 ;
  public static final int     ballenKaartFormaat   =  5 ;
  public static final int     ballenVlakFormaat    = 50 ;
  public static final String  ballenSchermIcoon    = "icon.ico" ;
  public static final String  ballenSchermTitel    = "Ballenscherm" ;
  public static final String  ballenSchermFont     = "Arial" ;
  public static final int     ballenschermFontMaat = 28 ;
  public static final boolean ballenSchermSpreekt  = true ;
  public static final boolean nietOpDeKaartKan     = false ;

  // -------------------------------------------------------------------------
  // DATA : inhoud van de ballenbak
  // -------------------------------------------------------------------------

  public static int aantal_genummerde_ballen = ballenKaartFormaat *
                                               ballenKaartFormaat ;
  public static int aantalGroeneBallen     = 3 ;
  public static int aantalRodeBallen       = 3 ;
  public static int aantalVraagtekenBallen = 1 ;

  // -------------------------------------------------------------------------
  // DATA : geluidsfragmenten
  // -------------------------------------------------------------------------

  public final static Geluidsfragment zoemer =
         new Geluidsfragment("", "zoemer", ".wav", 200) ;
  // -------------------------------------------------------------------------
  // DATA : afbeeldingen
  // -------------------------------------------------------------------------

  public static Afbeelding speelVeld =
         new Afbeelding("","achtergrond",".jpg") ;


  // --------------------------------------------------------------------------
  // METHOD : void instellen()
  // --------------------------------------------------------------------------
  /**
   * Het instellen van de configuratie
   */
  public static void instellen( )
  {
          /**
           * Mogelijkheid om naam van presentator te wijzigen
           */
          presentator.wijzigNaam(presentatorNaam[0]);

          /**
           * haal de instellingen voor alle gebruikte mappen op.
           */
          haal_mappen_info() ;
  }

  // --------------------------------------------------------------------------
  // METHOD : void haal_mappen_info()
  // --------------------------------------------------------------------------
  /**
   * Het ophalen van alle gegevens over bestandsmappen
   */
  private static void haal_mappen_info()
  {
   /**
    * haal de huidige directory op
    */
    huidigeMap = System.getProperty("user.dir").concat("\\") ;

    /**
     * stel de geluidsmap in
     */
    geluidMap = huidigeMap.concat(naamGeluidMap) ;

    /**
     * stel de beeld_map in
     */
    beeldMap = huidigeMap.concat(naamBeeldMap) ;
  }

    private void jbInit() throws Exception {
    }

}

//EINDE CONFIG

De class waar het op toegpast moet worden

code:

// --------------------------------------------------------------------------
// CLASS : Woordscherm
// --------------------------------------------------------------------------

// imports
import javax.swing.* ;
import java.awt.* ;

/**
 *
 * Het woordscherm van het programma Lingo <BR>
 * versie        : 1.7                     <BR><BR>
 *
 * Copyright (c) : J.H. Kalse M.Sc. 2005   <BR>
 */
public class Woordscherm extends JFrame
{

  // -------------------------------------------------------------------------
  // DATA : woordscherm configuratie gegevens
  // -------------------------------------------------------------------------

  // De hoogte van het woordscherm in aantal regels
  private final int     AANTAL_REGELS = Config.woordSchermRegels ;

  // De lengte van het woordscherm in karakters ( =  lengte te raden  woord )
  private final int     WOORD_LENGTE = Config.woordLengte ;

  // De hoogte en de breedte ( in pixels ) van het vlak waar een letter in staat
  private final int     LETTER_VLAK_FORMAAT = Config.woordSchermVlakFormaat ;

  // De naam van het voor dit scherm gebruikte icoon
  private final String  ICOON = Config.woordSchermIcoon ;

  // De titel van dit scherm
  private final String  TITEL = Config.woordSchermTitel ;

  // De naam van het lettertype dat in gebruik is voor dit scherm
  private final String  FONT = Config.woordSchermFont ;

  // De afmeting ( in pixels ) van het gebruikte lettertype
  private final int     FONT_MAAT = Config.woordSchermFontMaat ;

  // De staat van het wel/niet spellen van het ingevoerde woord
  private final boolean SPEL_WOORD = Config.woordSchermSpellen ;

  // -------------------------------------------------------------------------
  // DATA : configuratie gegevens geluid ( algemeen )
  // -------------------------------------------------------------------------

  // Nieuw woord : geluid bij een nieuw te raden woord
  public static Geluidsfragment NIEUW_WOORD =
         new Geluidsfragment( "","nieuwwoord",".wav",750) ;

  // Beurt kwijt : geluid bij het kwijtraken van de beurt
  public static Geluidsfragment BEURT_KWIJT =
         new Geluidsfragment( "","beurtkwijt",".wav",4000) ;

       // Toon hoog : juiste letter op de juiste plaats
       public static Geluidsfragment TOON_HOOG =
              new Geluidsfragment("", "hoog", ".wav", 175) ;

       // Toon midden : juiste letter maar niet op de juiste plaats
       public static Geluidsfragment TOON_MIDDEN =
              new Geluidsfragment("", "midden", ".wav", 175) ;

       // Toon laag : deze letter komt niet voor
       public static Geluidsfragment TOON_LAAG =
              new Geluidsfragment("", "laag", ".wav", 175) ;



  // -------------------------------------------------------------------------
  // DATA : Intern gehanteerde coderingen voor status letter op woordkaart
  // -------------------------------------------------------------------------

  private static final int IS_ONJUISTE_LETTER = 0 ;
  private static final int IS_JUISTE_LETTER   = 1 ;
  private static final int IS_JUISTE_PLAATS   = 2 ;

  // -------------------------------------------------------------------------
  // DATA : letters van het alfabet ( geluidsfragment )
  // -------------------------------------------------------------------------

  private Geluidsfragment a =  new Geluidsfragment("","a",".wav",390) ;
  private Geluidsfragment b =  new Geluidsfragment("","b",".wav",450) ;
  private Geluidsfragment c =  new Geluidsfragment("","c",".wav",520) ;
  private Geluidsfragment d =  new Geluidsfragment("","d",".wav",490) ;
  private Geluidsfragment e =  new Geluidsfragment("","e",".wav",340) ;
  private Geluidsfragment f =  new Geluidsfragment("","f",".wav",450) ;
  private Geluidsfragment g =  new Geluidsfragment("","g",".wav",490) ;
  private Geluidsfragment h =  new Geluidsfragment("","h",".wav",560) ;
  private Geluidsfragment i =  new Geluidsfragment("","i",".wav",310) ;
  private Geluidsfragment j =  new Geluidsfragment("","j",".wav",550) ;
  private Geluidsfragment k =  new Geluidsfragment("","k",".wav",420) ;
  private Geluidsfragment l =  new Geluidsfragment("","l",".wav",400) ;
  private Geluidsfragment m =  new Geluidsfragment("","m",".wav",410) ;
  private Geluidsfragment n =  new Geluidsfragment("","n",".wav",410) ;
  private Geluidsfragment o =  new Geluidsfragment("","o",".wav",500) ;
  private Geluidsfragment p =  new Geluidsfragment("","p",".wav",500) ;
  private Geluidsfragment q =  new Geluidsfragment("","q",".wav",440) ;
  private Geluidsfragment r =  new Geluidsfragment("","r",".wav",330) ;
  private Geluidsfragment s =  new Geluidsfragment("","s",".wav",560) ;
  private Geluidsfragment t =  new Geluidsfragment("","t",".wav",440) ;
  private Geluidsfragment u =  new Geluidsfragment("","u",".wav",300) ;
  private Geluidsfragment v =  new Geluidsfragment("","v",".wav",370) ;
  private Geluidsfragment w =  new Geluidsfragment("","w",".wav",540) ;
  private Geluidsfragment x =  new Geluidsfragment("","x",".wav",600) ;
  private Geluidsfragment y =  new Geluidsfragment("","y",".wav",560) ;
  private Geluidsfragment z =  new Geluidsfragment("","z",".wav",480) ;
  private Geluidsfragment ij =  new Geluidsfragment("","ij",".wav",330) ;

  // --------------------------------------------------------------------------
  // DATA : GridLayout grid
  // --------------------------------------------------------------------------
  /**
   * Bevat de layout van het scherm met woorden.
   * De lengte en breedte van dit scherm zijn afhankelijk van hetgeen
   * is opgegeven in de configuratie
   * */
  private GridLayout grid = new GridLayout(AANTAL_REGELS,WOORD_LENGTE) ;


  // --------------------------------------------------------------------------
  // DATA : JTextPane[][] veld
  // --------------------------------------------------------------------------
  /**
   * Bevat alle velden waarop 'letter en kleur' worden weergegeven
   * Het aantal velden is afhankelijk van hetgeen is opgegeven in
   * de configuratie voor de lengte van het woordscherm en de woordlengte
   * */
  private JTextPane[][] veld = new JTextPane[AANTAL_REGELS][WOORD_LENGTE] ;


  // --------------------------------------------------------------------------
  // DATA : String[][] letter
  // --------------------------------------------------------------------------
  /**
   * Bevat alle letters die op het woordscherm worden weergegeven
   * Het aantal letters is afhankelijk van hetgeen is opgegeven in
   * de configuratie voor de lengte van het woordscherm en de woordlengte
   * */
  private String[][] letter =  new String[AANTAL_REGELS][WOORD_LENGTE] ;


  // --------------------------------------------------------------------------
  // DATA : String[][] status
  // --------------------------------------------------------------------------
  /**
   * Bevat van iedere letter die op het woordscherm worden weergegeven
   * de status ( 0 = onjuist, 1 = juiste letter, 2 = juiste plaats )
   * Het aantal statussen is afhankelijk van hetgeen is opgegeven in
   * de configuratie voor de lengte van het woordscherm en de woordlengte
   * */
  private int[][] status = new int[AANTAL_REGELS][WOORD_LENGTE] ;


  // --------------------------------------------------------------------------
  // DATA : int woord_rij
  // --------------------------------------------------------------------------
  /**
   * De rij op het scherm die het nu in te vullen woord bevat
   * */
  private int woordRij = 0 ;

  // --------------------------------------------------------------------------
  // DATA : boolean einde_kaart
  // --------------------------------------------------------------------------
  /**
   * Geeft aan of op het scherm de laatste woordrij is bereikt
   * */
  private boolean eindeKaart = false ;


  // --------------------------------------------------------------------------
  // DATA : char[] juiste_letter
  // --------------------------------------------------------------------------
  /**
   * Bevat de reeds juist geraden letters
   * */
  private char[] juistKarakter = new char[WOORD_LENGTE] ;


  // --------------------------------------------------------------------------
  // DATA : String gevonden_letters
  // --------------------------------------------------------------------------
  /**
   * Bevat de reeds juist geraden letters
   * */
  private String gevonden_letters  = "";


  // --------------------------------------------------------------------------
  // DATA : te_raden_woord
  // --------------------------------------------------------------------------
  /**
   * Bevat het te raden woord
   * */
  private String te_raden_woord = "";


  // --------------------------------------------------------------------------
  // CONSTRUCTOR :
  // --------------------------------------------------------------------------
  /**
   * Maakt een woordscherm en draagt zorg voor de indeling van dat scherm.
   * */
  public Woordscherm()
  {

    // haal de toolkit op
    Toolkit tk = this.getToolkit() ;

    // haal een ICOON op
    Image ic = tk.getImage(Config.beeldMap.concat(ICOON)) ;

    // gebruik voor dit scherm het opgehaalde ICOON
    this.setIconImage(ic) ;

    // stel de TITEL voor dit scherm in
    setTitle(TITEL) ;

    // stel het formaat van het woordscherm in
    this.setSize(WOORD_LENGTE  * LETTER_VLAK_FORMAAT,
                 AANTAL_REGELS * LETTER_VLAK_FORMAAT) ;

    // zorg evoor dat het woordscherm zichtbaar is
    this.setVisible(false) ;

    // maak een container aan voor de inhoud van dit frame
    Container container = getContentPane() ;

    // stel de layout van de container
    container.setLayout(new GridLayout(AANTAL_REGELS,
                                       WOORD_LENGTE)) ;

    // voor alle rijen op het woordscherm
    for (int rij = 0 ; rij < AANTAL_REGELS ; rij++)
    {

      // voor alle kolommen in die rijen
      for (int kolom = 0 ; kolom < WOORD_LENGTE ; kolom++)
      {

        // maak een nieuw object aan voor een het veld[rij][kolom]
        veld[rij][kolom] = new JTextPane() ;

        // maak dit veld niet toegankelijk voor bewerking
        veld[rij][kolom].setEditable(false) ;

        // stel voor dit veld het lettertype en het letterformaat in
        veld[rij][kolom].setFont(new java.awt.Font(FONT, Font.BOLD, FONT_MAAT));

        // stel de kleur in voor de achtergrond
        veld[rij][kolom].setBackground(Color.BLUE) ;

        // stel de kleur in voor de letters
        veld[rij][kolom].setForeground(Color.WHITE) ;

        // plaats een randje rondom ieder veld
        veld[rij][kolom]
          .setBorder(BorderFactory.createLineBorder(Color.LIGHT_GRAY, 1)) ;

        // voeg dit veld toe aan het scherm
        container.add(veld[rij][kolom]) ;
      }
    }
        try {
            jbInit();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


  // --------------------------------------------------------------------------
  // METHOD : void verberg()
  // --------------------------------------------------------------------------
  /**
   * Verberg het woordscherm
   * */
  public void verberg()
  {
    this.setVisible(false) ;
  }


  // --------------------------------------------------------------------------
  // METHOD : void toon()
  // --------------------------------------------------------------------------
  /**
   * Toon het woordscherm
   * */
  public void toon()
  {
    this.setVisible(true) ;
  }


  // --------------------------------------------------------------------------
  // METHOD : void nieuw_te_raden_woord(String moet_worden_geraden)
  // --------------------------------------------------------------------------
  /**
   * Het nieuwe te raden woord wordt aan het woordscherm doorgegeven.
   * Het woordscherm en alle daarbij behorende gegevensworden teruggezet
   * in de uitgangspositie. Het te raden woord staat in uppercase met
   * het lowercase teken 'y' als het vervangende teken voor de lange ij.
   * */
  public void nieuw_te_raden_woord(String moet_worden_geraden)
  {
    // stel het te raden woord in
    te_raden_woord = moet_worden_geraden ;

    // voor alle rijen
    for (int rij = 0 ; rij < letter.length ; rij++)
    {
      // voor alle kolommen in die rijen
      for (int kolom = 0 ; kolom < WOORD_LENGTE ; kolom++)
      {

        // verwijder de letters van de kaart
        letter[rij][kolom] = " " ;

        // reset de status
        status[rij][kolom] = 0 ;

        // reset de juiste letters
        juistKarakter[kolom] = ' ' ;
      }
    }
    // zet de woordrij treug naar de bovenste regel
    woordRij = 0 ;

    // reset de reeds gevonden letters
    gevonden_letters = "" ;
    for (int i = 0 ; i < WOORD_LENGTE ; i++)
    {
      // voeg spaties toe aan de string met gevonden letters
      gevonden_letters = gevonden_letters.concat(" ") ;
    }

    // plaats de eerste letter van het te raden woord op het scherm
    letter[0][0] = " ".concat(Character.toString(te_raden_woord.charAt(0))) ;

    // zet de status van de eerste letter op "juiste plaats"
    status[0][0] = IS_JUISTE_PLAATS ;

    // Speel geluidje voor nieuw woord
    Geluid.afspelen(NIEUW_WOORD) ;

    // Toon het woordscherm.
    toon_scherm() ;
    if (SPEL_WOORD)
    {
      String geluidsbestand = Character.toString(te_raden_woord.charAt(0)).
                              concat(".wav") ;
      Geluid.afspelen(geluidsbestand, 525) ;
    }

  }


  // --------------------------------------------------------------------------
  // METHOD : raad_woord(String te_raden_woord, String dit_woord,
  //                     String team_naam)
  // --------------------------------------------------------------------------
  /**
   *
   * */
  public boolean team_raad_woord(String dit_woord)
  {
    if (SPEL_WOORD)
    {
      spel_woord(dit_woord) ;
    }

    // de tabel met status per letter die op het bord getoont worden
    int[] status = new int[WOORD_LENGTE] ;

    // array van gebruikte letters uit het te raden woord
    boolean[] gebruikt = new boolean[WOORD_LENGTE] ;

    // de array voor in de vergelijking verbruikte letters
    // zet de toestand verbruikt voor iedere letter op false
    for (int index = 0 ; index < gebruikt.length ; index++)
    {

      // deze letter is nog niet gebruikt
      gebruikt[index] = false ;
    }

    // reset status naar alle letters onjuist
    for (int kolom = 0 ; kolom < WOORD_LENGTE ; kolom++)
    {

      // zet de status van deze letter op "onjuiste letter"
      status[kolom] = IS_ONJUISTE_LETTER ;
    }

    // vergelijk het opgegeven woord met het te raden woord en
    // vul de statustabel

    // juiste letter op de juiste plaats
    for (int kolom = 0 ; kolom < dit_woord.length() ; kolom++)
    {
      if (te_raden_woord.charAt(kolom) == dit_woord.charAt(kolom))
      {
        // juiste letter juiste plaats
        status[kolom] = IS_JUISTE_PLAATS ;

        // neem deze letter op in de reeks van gevonden letters
        bij_gevonden(dit_woord.charAt(kolom), kolom) ;

        // deze letter is nu gebruikt
        gebruikt[kolom] = true ;
      }
    }

    // gebruikt heeft hier betrekking op posities in zowel
    // het te raden woord als het opgeven woord.
    // voor iedere letter in het gegeven woord wordt
    // nagegaan of die letter in het te raden woord staat
    for (int gegeven_kolom = 0 ;
                             gegeven_kolom < te_raden_woord.length() ;
                             gegeven_kolom++)
    {

      //
      for (int te_raden_kolom = 0 ;
                                te_raden_kolom < te_raden_woord.length() ;
                                te_raden_kolom++)
      {
        //
        if ((dit_woord.charAt(gegeven_kolom) ==
             te_raden_woord.charAt(te_raden_kolom)) &&
            (gebruikt[te_raden_kolom] == false))
        {
          // juiste letter maar verkeerde plaats
          if (status[gegeven_kolom] == 0)
          {

            //
            status[gegeven_kolom] = IS_JUISTE_LETTER ;

            //
            gebruikt[te_raden_kolom] = true ;
          }
        }
      }
    }

    //
    boolean woord_geraden = plaats_woord(dit_woord, status) ;

    //
    boolean beurt_kwijt = false ;

    //
    if ((einde_kaart_bereikt()) && (!woord_geraden))
    {

      //
      Geluid.afspelen(BEURT_KWIJT) ;

      //
      beurt_kwijt = true ;
    }

    //
    return beurt_kwijt ;
  }

  // --------------------------------------------------------------------------
  //                       *** PRIVATE METHODS ***
  // --------------------------------------------------------------------------
  /**
   * <HR>
   * PRIVATE METHODS
   * <HR>
   */

  // --------------------------------------------------------------------------
  // METHOD : spel_woord(String dit_woord)
  // --------------------------------------------------------------------------
  /**
   *
   * */
  public void spel_woord(String dit_woord)
  {
    for (int index = 0 ; index < WOORD_LENGTE ; index++)
    {
      int letternummer = dit_woord.charAt(index) - 64 ;

      if (letternummer > 26)
      {
        letternummer = 27;
      }

      switch (letternummer)
      {
        case  1: Geluid.afspelen(a ) ;  break ;
        case  2: Geluid.afspelen(b ) ;  break ;
        case  3: Geluid.afspelen(c ) ;  break ;
        case  4: Geluid.afspelen(d ) ;  break ;
        case  5: Geluid.afspelen(e ) ;  break ;
        case  6: Geluid.afspelen(f ) ;  break ;
        case  7: Geluid.afspelen(g ) ;  break ;
        case  8: Geluid.afspelen(h ) ;  break ;
        case  9: Geluid.afspelen(i ) ;  break ;
        case 10: Geluid.afspelen(j ) ;  break ;
        case 11: Geluid.afspelen(k ) ;  break ;
        case 12: Geluid.afspelen(l ) ;  break ;
        case 13: Geluid.afspelen(m ) ;  break ;
        case 14: Geluid.afspelen(n ) ;  break ;
        case 15: Geluid.afspelen(o ) ;  break ;
        case 16: Geluid.afspelen(p ) ;  break ;
        case 17: Geluid.afspelen(q ) ;  break ;
        case 18: Geluid.afspelen(r ) ;  break ;
        case 19: Geluid.afspelen(s ) ;  break ;
        case 20: Geluid.afspelen(t ) ;  break ;
        case 21: Geluid.afspelen(u ) ;  break ;
        case 22: Geluid.afspelen(v ) ;  break ;
        case 23: Geluid.afspelen(w ) ;  break ;
        case 24: Geluid.afspelen(x ) ;  break ;
        case 25: Geluid.afspelen(y ) ;  break ;
        case 26: Geluid.afspelen(z ) ;  break ;
        case 27: Geluid.afspelen(ij) ;  break ;
      }

    }
  }

  // --------------------------------------------------------------------------
  // METHOD : void toon_scherm()
  // --------------------------------------------------------------------------
  /**
   * Toont het woordscherm op basis van de huidige gegevens ten aanzien van
   * letters en hun status. Een en ander zonder geluid te produceren.
   * */
  private void toon_scherm()
  {

    // voor iedere rij op de woordkaart
    for (int rij = 0 ; rij < AANTAL_REGELS ; rij++)
    {

      // voor iedere kolom in de rijen
      for (int kolom = 0 ; kolom < WOORD_LENGTE ; kolom++)
      {
        // bereken het volgnummer van het vlak op het scherm
        int nr = (rij * WOORD_LENGTE) + kolom ;

        /* ----------------------------------------
           als een vervangend teken voor "lange ij"
           voorkomt in het woord toon dan een
           "lange ij" anders toon het teken zelf
         */

        // Als er een vervangend teken voor een "lange ij"
        // in het woord staat
        if (letter[rij][kolom].equals(" y"))
        {
          // toon dan een "lange ij"
          this.veld[rij][kolom].setText("  IJ") ;
        }
        else
        {
          // anders toon het teken zelf
          this.veld[rij][kolom].setText(" " + letter[rij][kolom]) ;
        }

        /* ----------------------------------------
           letter komt niet voor
           plaats een blauw vlak bij deze letter en
           laat een lage toon horen
         */
        if (status[rij][kolom] == 0)
        {
          this.veld[rij][kolom].setBackground(Color.blue) ;
        }

        /* ----------------------------------------
           letter komt voor maar plaats is onjuist
           plaats een geel vlak bij deze letter en
           laat een midden toon horen
         */
        // als de letter voorkomt maar de plaats is onjuist
        if (status[rij][kolom] == 1)
        {

          // maak de achtergrond bij deze letter oranje
          this.veld[rij][kolom].setBackground(Color.orange) ;

          // Als dit woord in de actuele woordrij staat en
        }

        /* ----------------------------------------
           letter komt voor en plaats is juist
           plaats een rood vlak bij deze letter en
           laat een hoge toon horen
         */

        // als de letter voorkomt en de plaats is juist
        if (status[rij][kolom] == 2)
        {
          // neem deze letter dan over in "juiste letter"
          juistKarakter[kolom] = letter[rij][kolom].charAt(1) ;

          // maak de achtergrond bij deze letter rood
          this.veld[rij][kolom].setBackground(Color.red) ;

        }
      }
    }

    // Toon dit scherm
    this.setVisible(true) ;
  }


  // --------------------------------------------------------------------------
  // METHOD : boolean toevoegen(boolean met_geluid)
  // --------------------------------------------------------------------------
  /**
   * Voeg een woord toe aan het woordscherm. Daarbij is het produceren van
   * geluiden op de actuele woordrij een optie
   * */
  private boolean toevoegen(boolean met_geluid)
  {
    // Zorg dat het woordscherm zichtbaar is
    this.setVisible(true) ;

    // Stel het aantal geraden letter op nul
    int geraden_letters = 0 ;

    // Neem aan dat het woord nog niet geraden is
    boolean woord_is_geraden = false ;

    // voor iedere rij op de woordkaart
    for (int rij = 0 ; rij < AANTAL_REGELS ; rij++)
    {

      // voor iedere kolom in de rijen
      for (int kolom = 0 ; kolom < WOORD_LENGTE ; kolom++)
      {

        // bereken het volgnummer van het vlak op het scherm
        int nr = (rij * WOORD_LENGTE) + kolom ;

        /* ----------------------------------------
           als een vervangend teken voor "lange ij"
           voorkomt in het woord toon dan een
           "lange ij" anders toon het teken zelf
         */

        // Als er een vervangend teken voor een "lange ij"
        // in het woord staat
        if (letter[rij][kolom].equals(" y"))
        {
          // toon dan een "lange ij"
          this.veld[rij][kolom].setText("  IJ") ;
        }
        else
        {
          // anders toon het teken zelf
          this.veld[rij][kolom].setText(" " + letter[rij][kolom]) ;
        }

        /* ----------------------------------------
           letter komt niet voor
           plaats een blauw vlak bij deze letter en
           laat een lage toon horen
         */
        if (status[rij][kolom] == 0)
        {
          this.veld[rij][kolom].setBackground(Color.blue) ;
          if (rij == woordRij)
          {
            // Als er geluid bij mag
            if (met_geluid)
            {
              // Speel het bijbehorende geluid af
              Geluid.afspelen(TOON_LAAG) ;
            }
          }
        }

        /* ----------------------------------------
           letter komt voor maar plaats is onjuist
           plaats een geel vlak bij deze letter en
           laat een midden toon horen
         */
        // als de letter voorkomt maar de plaats is onjuist
        if (status[rij][kolom] == 1)
        {

          // maak de achtergrond bij deze letter oranje
          this.veld[rij][kolom].setBackground(Color.orange) ;

          // Als dit woord in de actuele woordrij staat en
          if (rij == woordRij)
          {
            // als er geluid bij mag
            if (met_geluid)
            {

              // speel dan  het bijbehorende geluid af
              Geluid.afspelen(TOON_MIDDEN) ;

            }
          }
        }

        /* ----------------------------------------
           letter komt voor en plaats is juist
           plaats een rood vlak bij deze letter en
           laat een hoge toon horen
         */

        // als de letter voorkomt en de plaats is juist
        if (status[rij][kolom] == 2)
        {
          //
          juistKarakter[kolom] = letter[rij][kolom].charAt(1) ;

          for (int i = 0 ; i < WOORD_LENGTE ; i++)
          {
            System.out.print(juistKarakter[i]) ;
          }
          System.out.println() ;

          // maak de achtergrond bij deze letter rood
          this.veld[rij][kolom].setBackground(Color.red) ;

          // Als dit woord in de actuele woordrij staat en
          if (rij == woordRij)
          {

            // als er geluid bij mag
            if (met_geluid)
            {

              // Speel dan het bijbehorende geluid af
              Geluid.afspelen(TOON_HOOG) ;

            }

            // Verhoog het aantal geraden letters
            geraden_letters++ ;

          }
        }
      }
    }

    // Als het aantal goed geraden letters (op juiste plaats) even groot is
    // als het aantal letters in het woord
    if (geraden_letters == WOORD_LENGTE)
    {
      // dan is het woord geraden.
      woord_is_geraden = true ;
      Config.presentator.spreek(Config.presentator.geraden);
    }

    // geef terug of het woord geraden is
    return woord_is_geraden ;
  }


  // --------------------------------------------------------------------------
  // METHOD : boolean plaats_woord( String dit_woord, int[] woord_status,
  //                                String team_naam )
  // --------------------------------------------------------------------------
  /**
   * Plaatst een nieuw woord op het woordscherm dat door een team is gegeven.
   * */
  private boolean plaats_woord(String dit_woord, int[] woord_status)
  {

    // Neem aan dat het einde van de kaart nog niet is bereikt.
    eindeKaart = false ;

    // Als de actuele woordrij het einde van de kaart bereikt
    if (woordRij >= (AANTAL_REGELS - 1))
    {
      // leg dan de woordrij vast op die plaats
      woordRij = letter.length - 1 ;
    }

    // voeg het opgeven woord in op de door woord_rij aangegeven
    // rij in de tabel

    //
    for (int kolom = 0 ; kolom < letter[woordRij].length ; kolom++)
    {
      //
      letter[woordRij][kolom] = " " + dit_woord.charAt(kolom) ;
    }

    //
    if (woordRij >= (AANTAL_REGELS - 1))
    {
      //
      eindeKaart = true ;
    }

    //
    status[woordRij] = woord_status ;

    //
    boolean woord_is_geraden = toevoegen(true) ;

    //
    if ((woordRij >= (AANTAL_REGELS - 1)) &&
        (woord_is_geraden == false))
    {
      //
      schuif_rijen() ;
    }

    // als de onderste rij van de tabel nog niet bereikt is
    // dan de woordrij voor het volgende woord verhogen.
    if (woordRij < letter.length - 1)
    {
      // Verhoog de woordrij
      woordRij++ ;
    }

    // Als het woord nog niet is geraden
    if (woord_is_geraden == false)
    {
      // Vul dan de juiste letters bij de volgende rij alvast in.
      voor_vullen() ;
    }
    return woord_is_geraden ;
  }


  // --------------------------------------------------------------------------
  // METHOD : void voor_vullen()
  // --------------------------------------------------------------------------
  /**
   *
   * */
  private void voor_vullen()
  {
    //
    for (int kolom = 0 ; kolom < letter[woordRij].length ; kolom++)
    {
      //
      letter[woordRij][kolom] = " " + juistKarakter[kolom] ;

      //
      if (juistKarakter[kolom] != ' ')
      {
        //
        this.veld[woordRij][kolom].setBackground(Color.BLUE) ;

        //
        this.veld[woordRij][kolom].setText("  " +
                                            Character.toString(juistKarakter[
          kolom])) ;
      }
    }
  }

  // --------------------------------------------------------------------------
  // METHOD : void schuif_rijen()
  // --------------------------------------------------------------------------
  /**
   *
   * */
  private void schuif_rijen()
  {

    // Maak een variabele aan voor rij
    int rij ;

    // voor alle rijen
    for (rij = 0 ; rij < AANTAL_REGELS - 1 ; rij++)
    {

      // voor alle kolommen in die rijen
      for (int kolom = 0 ; kolom < letter[rij].length ; kolom++)
      {

        // verplaats de status 1 rij omhoog
        status[rij][kolom] = status[rij + 1][kolom] ;

        // verplaats het woord 1 rij omhoog
        letter[rij][kolom] = letter[rij + 1][kolom] ;
      }
    }

    // maak de onderste rij op de leeg
    for (int kolom = 0 ; kolom < letter[rij].length ; kolom++)
    {

      // maak de onderste rij leeg
      letter[rij][kolom] = "" ;

      // reset de status van de onderste rij
      status[rij][kolom] = 0 ;
    }

    // Plaats dit zonder geluid te maken op het scherm
    toevoegen(false) ;
  }


  // --------------------------------------------------------------------------
  // METHOD : void bij_gevonden(char letter, int positie)
  // --------------------------------------------------------------------------
  /**
   *
   * */
  private void bij_gevonden(char letter, int positie)
  {
    gevonden_letters = gevonden_letters.substring(1, (positie + 1)) +
                       letter +
                       gevonden_letters.substring(positie,
                                                  gevonden_letters.length()) ;

  }


  // --------------------------------------------------------------------------
  // METHOD : boolean einde_kaart_bereikt()
  // --------------------------------------------------------------------------
  /**
   * Geef terug of het einde van het woordscherm is bereikt
   * */
  private boolean einde_kaart_bereikt()
  {

    // Geef terug of het einde van het scherm is bereikt
    return eindeKaart ;
  }


  // --------------------------------------------------------------------------
  // METHOD : char begin_letter()
  // --------------------------------------------------------------------------
  /**
   *
   * */
  private char begin_letter()
  {

    // Geef de eerste letter van het te raden woord terug
    return te_raden_woord.charAt(0) ;
  }

    private void jbInit() throws Exception {
        this.setIconImage(null);
    }

} // EINDE CLASS

[whoami]

Hoi,

Ik denk niet dat 1000 regels code relevant is voor jouw vraag. Het is dus niet de bedoeling dat je die hele lap code hier post; en al zeker niet als die irrelevant is.
Daarnaast denk ik dat jouw vraag redelijk snel op te lossen is, als je eens de manual bekijkt, of eens gericht naar een tutorial gaat zoeken.