JSBS_ImagePane – Ein GUI-Element zur Anzeige eines Image

Inhaltsverzeichnis

Übersichtsbeschreibung 
Code 
Erklärungen und Anwendungsbeispiele 
* Erstellen eines Objektes dieser Klasse 
* Zuordnen eines Objektes des Klasse 'JLabel' für die Anzeige der Image-Größe 
* Festlegen der Texte für das Kontext-Menu 
* Reagieren auf eine Änderung des angezeigten Images 
* Transferieren des Images in das / aus dem JSBS_ImagePane 
* Importieren des Images von einer Datei 
* Exportieren des Images auf eine Datei 
* Schreiben auf eine / Lesen von einer Datenbank 
Verwandte Dokumentation 

Übersichtsbeschreibung

Diese Klasse ist ein GUI-Element für die Anzeige von Images (Fotos oder Grafiken).
Durch den Aufruf verschiedener Methoden können zwei mögliche Arten der Darstellung des Images gewählt werden.

Weitere Möglichkeiten zur Steuerung finden Sie im Abschnitt Erklärungen und Anwendungsbeispiele.

Code

package js_base.frame;

import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
/**
 *
 * @author kurt[at]javascout(dot)biz
 * @date 2010-08-16
 *
 * @description
 *  de:
 *  Spezielles GUI-Element für die Anzeige von Images (Fotos, Grafiken).
 *  Durch eine Einstellung innerhalb der Klasse
 *  (gesteuert durch einen Constructor-Parameter oder durch Methoden)
 *  kann entschieden werden, ob
 *  * das Image verkleinert als Ganzes im zum Verfügung stehenden Platz auf der GUI oder
 *  * das Image in voller Auflösung mit Scrollbars
 *  angezeigt wird.
 *  -------------------
 *  en:
 *  Special GUI-Element to display Images (photos, graphics).
 *  A setup within the class (controlled by a constructor-parameter or methods)
 *  allows to decide, if
 *  * the Image is shrinked and shown as a whole within the available space on the GUI or
 *  * The Image is shown with full resolution and scrollbars.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class JSBS_ImagePane extends JScrollPane {
/*
 * Variable der Klasse / variables of the class. */
/* 
 * de:
 * Gesamtes Image in ursprünglicher Auflösung.
 * Verwendet wird ein ImageIcon um auch animierte GIF-Dateien anzeigen zu können.
 * en:
 * Complete Image in original resolution.
 * An ImageIcon is used to display so that animated GIF-graphics can be displayed, too. */
    private ImageIcon imgFullResolution;
/* 
 * de:
 * Image in Form eines Byte-Streams. Das ist notwendig wenn ein animiertes GIF angezeigt werden soll.
 * Anmerkung:
 * Für animierte GIFs habe ich keine Möglichkeit gefunden, den Bytestream für das Speichern in einer Datei
 * oder auf einer Datenbank wieder aus dem ImageIcon herzustellen.
 * Um in den Methoden ein konsistentes Verhalten für alle Grafik-Typen zu erreichen, wird ein
 * übergebenener Bytestream in dieser Variablen gespeichert und auf Anforderung durch die Methode
 * 'getImageAsByteArray()' wieder zurück geliefert.
 * en:
 * Image in the form of a byte-stream. That is needed to display an animated GIF.
 * Remark:
 * I did not find any algorithm to derive a bytestream – needed to save in a file or on a database -
 * from an ImageIcon.
 * To offer consistant behaviour for all types of graphics within the methods, a passed bytestream
 * is stored in this variable an returned if requested by the method 'getImageAsByteArray()'. */
    private byte[] arrayImageAsBytes = new byte[0];
/* 
 * de:
 * Grafik-Typ, der gemeinsam mit dem Image als Bytestream übergeben werden muss oder der beim
 * Erstellen des Bytestreams für die Grafik verwendet wurde.
 * en:
 * Graphics-type that has to be passed together with the Image as bytestream or is used when
 * the bytestream is generated out of the ImageIcon. */
    private String strGraphicFormat = "";
/* 
 * de:
 * Marker ob das Image in voller Auflösung (mit Scrollbalken) oder
 * verkleinert als Ganzes auf der zur Verfügung stehenden Fläche der GUI
 * angezeigt werden soll.
 * en:
 * Flag if the Image should be shown with full resolution (with scrollbars) or
 * the Image should be shrinked to fit into the given space on the GUI. */
    private boolean bolDisplayFullResolution;
/* 
 * de:
 * Möglicherweise als Parameter übergebenes GUI-Element zur Anzeige der Anzahl der
 * horizontalen und vertikalen Pixel (Bildpunkte) aus denen das Image aufgebaut ist.
 * en:
 * GUI-Element – optionally passed as parameter – to display the number of horizontal
 * and vertoical pixels that make up the image. */
    private JLabel lbl_ImageInfoResolution;
/* 
 * de:
 * Innere Klasse für die Aufbereitung (wenn notwendig Verkleinerung) und Anzeige
 * des Images.
 * en:
 * Inner class to treat (resizing if neccessary) and display of the image. */
    private JSBS_InternalImagePane pnl_Internal;
/* 
 * de:
 * Texte für das Context-Menu über dem Image mit der Auswahl für Kopieren oder Einfügen.
 * Diese Texte können mit der Methode 'setLanguageSpecificMenuTexts' verändert werden.
 * en:
 * Texts for the context-menu over the image with the selection for copy and paste.
 * These texts can be changed using the method 'setLanguageSpecificMenuTexts'. */
    private String strMenuTextCopy = "copy (to clipboard)";
    private String strMenuTextPaste = "paste (from clipboard)";
/*
 * ************************************************** */
/* 
 * de:
 * Standard-'Constructor' der Klasse mit allen möglichen Parametern.
 * en:
 * Standard-'Constructor' of the class with all possible parameters. */
    public JSBS_ImagePane(ImageIcon parmImageIcon, boolean parmDisplayFullResolution, JLabel parmImageInfoResolution) {
/* de: Aufrufen des 'Constructor' der Superklasse (JLabel).
 * en: Call the 'Constructor' of the superclass (JLabel). */
      super();
/* de: Übertragen der Parameter-Werte in die Variablen dieses Klasse.
 * en: Transfer the parameter-values into the variables of this class. */
      imgFullResolution = parmImageIcon;
      bolDisplayFullResolution = parmDisplayFullResolution;
      lbl_ImageInfoResolution = parmImageInfoResolution;
/* de:
 * Konstruieren eines Objekts der inneren Klasse, dieses in den 'Viewport' aufnehmen
 * und übergeben des Images.
 * en:
 * Construct an object of the inner class, add this to the 'Viewport' and pass the image. */
      pnl_Internal = new JSBS_InternalImagePane(this);
      this.setViewportView(pnl_Internal);
      pnl_Internal.setImage();
    }
/* 
 * de: Abwandlungen des 'Constructor'.
 * en: Derivations of the 'Constructor'. */
    public JSBS_ImagePane(boolean parmDisplayFullResolution, JLabel parmImageInfoResolution) {
/* de: Aufrufen des 'Constructor' der Superklasse (JLabel).
 * en: Call the 'Constructor' of the superclass (JLabel). */
      super();
/* de: Füllen der Variablen für nicht übergebenen Werte mit Standard-Werten.
 * en: Fill the variables for not passed values with standard-values. */
      imgFullResolution = null;
/* de: Übertragen der Parameter-Werte in die Variablen dieses Klasse.
 * en: Transfer the parameter-values into the variables of this class. */
      bolDisplayFullResolution = parmDisplayFullResolution;
      lbl_ImageInfoResolution = parmImageInfoResolution;
/* de:
 * Konstruieren eines Objekts der inneren Klasse, dieses in den 'Viewport' aufnehmen
 * und übergeben des Images.
 * en:
 * Construct an object of the inner class, add this to the 'Viewport' and pass the image. */
      pnl_Internal = new JSBS_InternalImagePane(this);
      this.setViewportView(pnl_Internal);
      pnl_Internal.setImage();
    }
/* ***** */
    public JSBS_ImagePane(boolean parmDisplayFullResolution) {
/* de: Aufrufen des 'Constructor' der Superklasse (JLabel).
 * en: Call the 'Constructor' of the superclass (JLabel). */
      super();
/* de: Füllen der Variablen für nicht übergebenen Werte mit Standard-Werten.
 * en: Fill the variables for not passed values with standard-values. */
      imgFullResolution = null;
      lbl_ImageInfoResolution = null;
/* de: Übertragen der Parameter-Werte in die Variablen dieses Klasse.
 * en: Transfer the parameter-values into the variables of this class. */
      bolDisplayFullResolution = parmDisplayFullResolution;
/* de:
 * Konstruieren eines Objekts der inneren Klasse, dieses in den 'Viewport' aufnehmen
 * und übergeben des Images.
 * en:
 * Construct an object of the inner class, add this to the 'Viewport' and pass the image. */
      pnl_Internal = new JSBS_InternalImagePane(this);
      this.setViewportView(pnl_Internal);
      pnl_Internal.setImage();
    }
/* ***** */
    public JSBS_ImagePane(JLabel parmImageInfoResolution) {
/* de: Aufrufen des 'Constructor' der Superklasse (JLabel).
 * en: Call the 'Constructor' of the superclass (JLabel). */
      super();
/* de: Füllen der Variablen für nicht übergebenen Werte mit Standard-Werten.
 * en: Fill the variables for not passed values with standard-values. */
      imgFullResolution = null;
      bolDisplayFullResolution = false;
/* de: Übertragen der Parameter-Werte in die Variablen dieses Klasse.
 * en: Transfer the parameter-values into the variables of this class. */
      lbl_ImageInfoResolution = parmImageInfoResolution;
/* de:
 * Konstruieren eines Objekts der inneren Klasse, dieses in den 'Viewport' aufnehmen
 * und übergeben des Images.
 * en:
 * Construct an object of the inner class, add this to the 'Viewport' and pass the image. */
      pnl_Internal = new JSBS_InternalImagePane(this);
      this.setViewportView(pnl_Internal);
      pnl_Internal.setImage();
    }
/* ***** */
    public JSBS_ImagePane() {
/* de: Aufrufen des 'Constructor' der Superklasse (JLabel).
 * en: Call the 'Constructor' of the superclass (JLabel). */
      super();
/* de: Füllen der Variablen für nicht übergebenen Werte mit Standard-Werten.
 * en: Fill the variables for not passed values with standard-values. */
      imgFullResolution = null;
      bolDisplayFullResolution = false;
      lbl_ImageInfoResolution = null;
/* de:
 * Konstruieren eines Objekts der inneren Klasse, dieses in den 'Viewport' aufnehmen
 * und übergeben des Images.
 * en:
 * Construct an object of the inner class, add this to the 'Viewport' and pass the image. */
      pnl_Internal = new JSBS_InternalImagePane(this);
      this.setViewportView(pnl_Internal);
      pnl_Internal.setImage();
    }
/* 
 * de: METHODE zum Zurückliefern des angezeigten Image.
 * en: METHOD to return the displayed image. */
    public ImageIcon getImage() {
      return imgFullResolution;
    }
/* 
 * de:
 * METHODE zum Zurückliefern des angezeigten Image als Array von Bytes.
 * en:
 * METHOD to return the displayed image as an array of bytes. */
    public byte[] getImageAsByteArray() {
/* de:
 * Aufrufen der gleichnamigen Methode mit dem Grafik-Format als Parameter.
 * Als Parameter wird 'null' übergeben; damit wird jenes Grafik-Format zurück geliefert das gemeinsam
 * mit einem Bytestream in der Methode 'setImage(byte[] parmImage, String parmGraphicsFormat)'
 * übergeben wurde. Wurde das Image über das Kontext-Menu 'Paste' oder mit der Methode
 * 'setImage(ImageIcon parmIMageIcon)' übernommen, dann wird das Standard-Format (jpg) verwendet.
 * en:
 * Call the method with the same name and the graphics-format as parameter.
 * 'null' is passed as parameter; that return the graphics-Format that was passed together with the
 * bytestream in the method 'setImage(byte[] parmImage, String parmGraphicsFormat)'.
 * If the image was inserted via the context-menu 'Paste' or with the method 'setImage(ImageIcon parmIMageIcon)',
 * then the standard-format (jpg) is used. */
      return getImageAsByteArray(null);
    }
/* 
 * de:
 * METHODE zum Zurückliefern des angezeigten Image als Array von Bytes.
 * Als Parameter wird das Grafik-Format übergeben.
 * en:
 * METHOD to return the displayed image as an array of bytes.
 * The graphics-format is passed as parameter. */
    public byte[] getImageAsByteArray(String parmGraphicsFormat) {
/* de:  
 * Wenn bereits ein Bystream erstellt ist und auch das Grafik-Format dafür festgelegt ist, 
 * dann wird der bereits vorhandene Bytestream zurück geliefert.
 * en:  
 * If there is already a bytestream defined and an graphics-format is attached to, 
 * then this already present bytestream is returned. */
      if ((arrayImageAsBytes.length > 0) && (strGraphicFormat.length() > 0))
        return arrayImageAsBytes;
/* de:    
 * Weitere Verarbeitung wenn noch kein Bytestream für das angezeigte Image erstellt wurde.
 * Zuerst Festlegen des Standard-Formats (JPG).
 * en:    
 * Further processing if there is not already a bytestream defined for the displayed image.
 * First define the standard-format (JPG). */
      String strInternalGraphicsFormat = "jpg";
/* de:
 * Wenn im Parameter ein Grafik-Format übergeben wurde dann zuerst mit dem bereits zum
 * Bytestream festgelegten Grafik-Format vergleichen.
 * Wurde noch kein Grafik-Format festgelegt wurde, dann das übergebene Grafik-Format für
 * weitere Verarbeitung verwenden.
 * en:
 * If a graphics-format parameter was passed, then this value is compared to the
 * graphics-format already defined for the bytestream.
 * If no graphics-format was already specified, then use the passed graphics-format for
 * further processing. */
      if (parmGraphicsFormat != null) strInternalGraphicsFormat = parmGraphicsFormat;
/* de: Aufheben des verwendeten Grafik-Formats in der Variablen dieser Klasse.
 * en: Keep the used graphics-format within the variable of this class. */
      strGraphicFormat = strInternalGraphicsFormat;
/* de:
 * Umwandeln eines Images in ein Byte-Attay erfordert mehrere Schritte.
 * Das ganze erfolgt innerhalb einer try-catch-Logik um Fehler abzufangen.
 * en:
 * Converting an Image to a byte-array requests multiple steps
 * The commands are within a try-catch-logic to catch and process errors. */
      try {
/* de:
 * Für den ersten Schritt der Umwandlung ist eine Vorbereitung wie zum Schreiben
 * auf eine Datei notwendig.
 * en:
 * The first step of converting requests a preparation like writing to a file. */
        ByteArrayOutputStream streamOut = new ByteArrayOutputStream();
/* de:
 * Umgewandelt in einen Bytestream kann nur ein Objekt der Klasse BufferedImage.
 * Dieses wird jetzt mit der gleichen Fläche wie das angezeigte Image 'konstruiert'.
 * en:
 * Only an object of class BufferedImage can be converted to a bytestream.
 * This BufferedImage-object is now constructed with the same area as the displayed image. */
        BufferedImage localBufferedImage = new BufferedImage(
                                          imgFullResolution.getImage().getWidth(null),
                                          imgFullResolution.getImage().getHeight(null),
                                          BufferedImage.TYPE_INT_RGB);
/* de:
 * Das Unterobjekt für die Grafik des gerade erstellten BufferedImage wird einer lokalen Variable
 * zugewiesen; der Bereich der Grafik wird initialisiert.
 * en:
 * The sub-object for the graphic of the just constructed BufferedImage is attached to a local
 * variable; the graphic-area is intialised. */
        Graphics2D localGraphics = localBufferedImage.createGraphics();
/* de:
 * In die Grafik des BufferedImage wird der Inhalt der Grafik des angezeigten Images übertragen.
 * -----------------
 * Einschränkung:
 * Auf diese Weise kann nur ein Image eines 'animierten GIF' übertragen werden !
 * ------------------
 * en:
 * The graphic of the BufferedImage is filled with the content of the graphic of the displayed image.
 * -------------------
 * Limitation:
 * This code allows only the transfer of one image of an 'animated GIF' !
 * ------------------- */
        localGraphics.drawImage(imgFullResolution.getImage(), 0, 0,
                                imgFullResolution.getImage().getWidth(null),
                                imgFullResolution.getImage().getHeight(null),
                                null);
/* de:
 * Methode zum 'Schreiben' des Images auf den Output-Stream aufrufen.
 * Als Parameter an die Methode wird auch das gewünschte Grafik-Format übergeben.
 * en:
 * Call the method to 'write' the image to an Output-Stream.
 * As one parameter to the method the requested graphics-format is passed. */
        ImageIO.write(localBufferedImage, strGraphicFormat, streamOut);
/* de: Byte-Array aus dem Stream extrahieren und zurück liefern.
 * en: Extract the byte-array out of the Stream and return it. */
        return streamOut.toByteArray();
      }
      catch (Exception Exc) {
/* de: Umwandeln des Images in das Byte-Array fehlgeschlagen; leeres Array zurück liefern.
 * en: Converting the image to a byte-array failed; return an empty array. */
        return new byte[0];
      }
    }
/* 
 * de: METHODE zum Auslesen des Grafik-Formats in dem der Bytestream des Images erstellt ist.
 * en: METHOD to read the graphics-format in which the bytestream of the image is constructed. */
    public String getGraphicsFormat() {
/* de: Die Variable dieser Klasse zurück liefern.
 * en: Return the variable of this class. */
      return strGraphicFormat;
    }
/* 
 * de: METHODE zum Anzeigen eines neuen Image.
 * en: METHOD to display a new image. */
    public void setImage(ImageIcon parmImage) {
/* de: Übertragen des Parameter-Wertes in die Variable dieser Klasse.
 * en: Transfer the parameter-value into the variable of this class. */
      imgFullResolution = parmImage;
/* de: 'Löschen' des Bytestreams für das Image und der Beschreibung für das Grafik-Format.
 * en: 'Delete' the bytestream for this image and the description of the graphics-format. */
      arrayImageAsBytes = new byte[0];
      strGraphicFormat = "";
/* de: Aufrufen der gleichnamigen Methode der inneren Klasse.
 * en: Call the method with the same name of the inner class. */
      pnl_Internal.setImage();
    }
/* 
 * de:
 * METHODE zum Anzeigen eines neuen Image.
 * Dieses wird in Form eines Array aus bytes übergeben und zusätzlich wird das Grafik-Format übergeben.
 * en:
 * METHOD to display a new image.
 * This is passed as an array of bytes and additionally the graphics-format is passed, too. */
    public void setImage(byte[] parmImage, String parmGraphicFormat) {
/* de:
 * Speichern beider Parameter in den dafür vorgesehenen Variablen dieser Klasse.
 * en:
 * Save both parameters in the assigned variables of this class. */
      arrayImageAsBytes = parmImage;
      strGraphicFormat = parmGraphicFormat;
/* de: Sicherheitsprüfung ob auch ein Wert übergeben wurde.
 * en: Safetycheck if a value was passed. */
      if (parmImage != null) {
/* de:
 * Umwandeln des Byte-Arrays (übergeben als Parameter) und übertragen in die Variable diese Klasse.
 * en:
 * Convert the byte-array (passed as parameter) and transfer into the variable of this class. */
        Image localImage = Toolkit.getDefaultToolkit().createImage(parmImage);
        imgFullResolution = new ImageIcon(localImage);
      }
      else {
/* de:
 * 'null' als Parameter übergeben; Image ebenfall auf 'null' setzen.
 * Damit wird in der Methode der internen Klasse eine leere Fläche angezeigt.
 * en:
 * 'null' passed as parameter. Set Image to 'null', too.
 * This causes the method within the internal class to display an empty area. */
        imgFullResolution = null;
      }
/* de: Aufrufen der gleichnamigen Methode der inneren Klasse.
 * en: Call the method with the same name of the inner class. */
      pnl_Internal.setImage();
    }
/* 
 * de: METHODE zum Anzeigen eines in der Zwischenablage (Clipboard) enthaltenen Image.
 * en: METHOD to display an image contained in the clipboard. */
    public void setImageFromClipboard() {
/* de:
 * Image aus dem Clipboard in ein 'ImageIcon' übernehmen und
 * Methode zum Anzeigen des ImageIcon aufrufen.
 * en:
 * Transfer the image from the clipboard into an 'ImageIcon' and
 * call the method to display the ImageIcon. */
      setImage(new ImageIcon(pnl_Internal.getImageFromClipboard()));
    }
/* 
 * de: METHODE zum Kopieren des angezeigten Images in die Zwischenablage (Clipboard).
 * en: METHOD to copy the displayed image into the clipboard. */
    public void putImageToClipboard() {
/* de: Methode der inneren Klasse aufrufen und dort die Arbeit machen lassen.
 * en: Call the method of the inner class and let the work do there. */
      pnl_Internal.putImageToClipboard();
    }
/* 
 * de:
 * METHODE zum Wechsel in den Anzeigemodus für die volle Auflösung des
 * Images mit Scroll-Balken (wenn notwendig).
 * en:
 * METHOD to switch to the full-resolution mode for the display and to
 * show scroll-bars (if neccessary). */
    public void setFullResolutionMode() {
/* de: Ändern des Markes in dieser Klasse.
 * en: Change the flag within this class. */
      bolDisplayFullResolution = true;
/* de: Aufrufen der Methode der inneren Klasse zum Neu-Anzeigen des Images.
 * en: Call the method of the inner class to redisplay the image. */
      pnl_Internal.setImage();
    }
/* 
 * de:
 * METHODE zum Wechsel in den Anzeigemodus für die Anzeige des Images
 * im verfügbaren Platz auf der GUI – mit Verkleinerung des Images wenn notwendig.
 * en:
 * METHOD to switch to the mode that shrinks (if neccessary) the image so that it
 * can be completely shown in the available space at the GUI. */
    public void setFitImageMode() {
/* de: Ändern des Markes in dieser Klasse.
 * en: Change the flag within this class. */
      bolDisplayFullResolution = false;
/* de: Aufrufen der Methode der inneren Klasse zum Neu-Anzeigen des Images.
 * en: Call the method of the inner class to redisplay the image. */
      pnl_Internal.setImage();
    }
/* 
 * de:
 * METHODE zum Übernehmen sprach-spezifischer Texte für die Auswahl im Kontext-Menu
 * das über dem Image erscheint.
 * Ein Parameterwert 'null' bewirkt, dass der Menu-Eintrag nicht angezeigt wird.
 * en:
 * METHOD to set language-specific texts for the selection in the context-menu
 * popping up over over the image.
 * A parameter-value 'null' prevents the menu-item to be shown. */
    public void setLanguageSpecificMenuTexts(String parmTextCopy, String parmTextPaste) {
      strMenuTextCopy = parmTextCopy;
      strMenuTextPaste = parmTextPaste;
    }
/* ********************
 * de:
 * INTERNE KLASSE für die Anzeige des Images.
 * Diese Innere Klasse ist notwendig, weil ein GUI-Element mit Scrollbalken
 * (JScrollPane) nur dafür vorgesehen ist, in seinem 'Viewport' ein anderes
 * GUI-Element anzuzeigen.
 * Dieses 'andere GUI-Element' (für die Anzeige des Images) wird in dieser Klasse
 * implementiert.
 * en:
 * INTERNAL CLASS to display the image.
 * This inner class is needed, because a GUI-Element with scrollbars (JScrollPane)
 * is only designed to show another GUI-Element within its 'Viewport'.
 * This 'other GUI-Element' (to display the image) is implemented by this
 * inner class. */
    class JSBS_InternalImagePane extends JLabel implements ActionListener, ClipboardOwner, MouseListener, MouseMotionListener, Scrollable {
/*
 * Variable der Klasse / variables of the class. */
/* 
 * de:
 * Anzahl der Pixel, um die beim Scrollen mit der Maus (mit Scrollrad oder per Drag)
 * das Image verschoben wird.
 * Dieser Wert wird abhängig von der Höhe des Images berechnet damit das Scrollen
 * mit der Maus auch in akzeptabler Geschwindigkeit passiert.
 * en:
 * Number of pixels the image is moved when the mouse (with scrollwheel or Drag) is used
 * to scroll the image.
 * This value is calculated depending on the height od the image to get a reasonable
 * speed when when scrolling using the mouse. */
    private int intScrollUnitIncrement = 10;
/* 
 * de:
 * Referenz auf das 'Scrollpane'; aus diesem werden die Dimensionen des Platzes
 * für das Image und Werte für die Steuerung der Anzeige ausgelesen.
 * en:
 * Reference to the 'Scrollpane'; from there the dimensions of the space for the
 * image and values to control the display are read. */
    private JSBS_ImagePane pnl_Parent;
/* 
 * de: Image in der Auflösung, die für die Anzeige notwendig ist.
 * en: Image in the resolution needed for display. */
    private ImageIcon imgToBeDisplayed;
/* 
 * de:
 * Kontext-Menu für das Image; erscheint nach einem Klick auf die rechte Maustaste
 * und erlaubt ein Kopieren des Images ins Clipboard bzw. ein Einfügen aus dem Clipboard.
 * en:
 * Context-menu for the image; appears after the right mouse-button is pressed and allows
 * a copy of the image to the clipboard or a paste from the clipboard. */
    private JPopupMenu mnuCopyPaste;
/*
 * ************************************************** */
/* 
 * de:
 * Standard-'Constructor' der Klasse; Parameter ist die Referenz auf das übergeordnete Pane.
 * Aus diesem werden die Werte für die Steuerung der Image-Anzeige ausgelesen.
 * en:
 * Standard-'Constructor' of the class; parameter is the reference to the higher-ranking pane.
 * From there the values to control the display of the image are read. */
    public JSBS_InternalImagePane(JSBS_ImagePane parmParent) {
/* 
 * de: Übernahme des Parameter-Wertes in die Variable dieser Klasse.
 * en: Transfer the parameter-value into the variable of this class. */
      pnl_Parent = parmParent;
/* 
 * de: Listener hinzufügen.
 * en: Add Listener. */
      addMouseMotionListener(this);
      addMouseListener(this);
    }
/*
 * ************************************************** */
/* 
 * de: METHODE zum Anzeigen eines Image.
 * en: METHOD to display an image. */
    public void setImage() {
/* 
 * de: Zur Sicherheit prüfen ob auch das (Parent-)ScrollPane übergeben wurde.
 * en: Verify for code-safety-reasons that the (parent-)ScrollPane was passed. */
      if (pnl_Parent == null) return;
/* de:
 * Ändern der 'Property' (Eigenschaft) für die Anzeige eines Scrollbalkens.
 * Damit kann durch einen Event signalisiert werden, dass das Image geändert wurde.
 * Dieser Event kann von einem 'Parent' in der GUI über einen 'PropertyChangeListener'
 * verarbeitet werden und so kann erkannt werden wenn ein Image durch das 'Paste' im
 * Kontext-Menu eingefügt wurde.
 * en:
 * Change the property for the appearance of a scrollbar.
 * This allows the change of the image to be signalled by an event.
 * This event can be processed by a 'parent' in the GUI by a 'PropertyChangeListener'
 * ans so can be recognized that an image was inserted using the 'Paste' of the context-menu. */
      pnl_Parent.setHorizontalScrollBarPolicy(HORIZONTAL_SCROLLBAR_ALWAYS);
/* 
 * de:
 * Prüfen, ob ein Image übergeben wurde; sonst als Hinweis ein fast weißes Rechteck anzeigen.
 * en:
 * Verify if an image was passed as parameter; otherwise display a nearly white rectangle as indicator. */
      if (pnl_Parent.imgFullResolution == null) {
        BufferedImage imgWhiteRectangle = new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB);
        for (int y = 0; y < 200; y++) {
          for (int x = 0; x < 200; x++) {
            imgWhiteRectangle.setRGB(y, x, (250 * 256 * 256) + (250 * 256) + 250);
          }
        }
        this.setIcon(new ImageIcon(imgWhiteRectangle));
/* 
 * de:
 * Wenn ein JLabel für die Anzeige der Größe des Images übergeben wurde dann wird der Text darin gelöscht.
 * en:
 * If a JLabel for the display of image-size was passed then the text of it is deleted. */
        if (pnl_Parent.lbl_ImageInfoResolution != null) lbl_ImageInfoResolution.setText("");
        return;
      }
/* 
 * de:
 * Übernehmen des Images aus dem ScrollPane in die Variable dieser Klasse.
 * Dazu wird ein neues Objekt konstruiert weil bei einer reinen Zuweisung auch die Variable im Parent-Panel
 * verkleinert werden würde.
 * en:
 * Transfer the image from the ScrollPane to the variable of this class.
 * For that a new variable is constructed, as with a reference only the variable in the parent-panel would be
 * shrinked, too. */
      imgToBeDisplayed = new ImageIcon(pnl_Parent.imgFullResolution.getImage());
/* 
 * de:
 * Ermitteln der Größe von verfügbarem Platz auf der GUI und Größe des anzuzeigenden Images.
 * en:
 * Determine the size of the available space on the GUI and the size of the image to be displayed. */
      int intImageWidth = imgToBeDisplayed.getIconWidth();
      int intImageHeight = imgToBeDisplayed.getIconHeight();
      int intScrollPaneWidth = pnl_Parent.getWidth();
      int intScrollPaneHeight = pnl_Parent.getHeight();
/* 
 * de:
 * Unterscheiden ob das Image mit voller Auflösung angezeigt werden soll (und wenn notwendig
 * Scroll-Balken eingeblendet werden) oder ob das Image verkleinert werden soll.
 * en:
 * Decide if the image should be shown with full resolution (and scroll-bars are inserted
 * if neccessary) or the image should be shrinked. */
      if (pnl_Parent.bolDisplayFullResolution) {
/* 
 * de: Anzeige mit voller Auflösung; weiter prüfen ob Scroll-Balken notwendig sind.
 * en: Display with full resolution; additional check if scrollbars are needed. */
        if ((intImageWidth > intScrollPaneWidth) || (intImageHeight > intScrollPaneHeight)) {
          pnl_Parent.setHorizontalScrollBarPolicy(HORIZONTAL_SCROLLBAR_AS_NEEDED);
          pnl_Parent.setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_AS_NEEDED);
        }
        else {
          pnl_Parent.setHorizontalScrollBarPolicy(HORIZONTAL_SCROLLBAR_NEVER);
          pnl_Parent.setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_NEVER);
        }
      }
      else {
/* 
 * de:
 * Image soll komplett angezeigt werden; d.h. s muss bei Bedarf verkleinert werden.
 * Zuerst die Anzeige von Scrollbalken 'ausschalten'.
 * en:
 * Image should be displayed as a whole; i.e. It must be shrinked if neccessary.
 * First 'switch off' the display of scrollbars. */
        pnl_Parent.setHorizontalScrollBarPolicy(HORIZONTAL_SCROLLBAR_NEVER);
        pnl_Parent.setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_NEVER);
/* 
 * de: Prüfen ob eine Verkleinerung des Images notwendig ist.
 * en: Verify if the image has to be shrinked. */
        if ((intImageWidth > intScrollPaneWidth) || (intImageHeight > intScrollPaneHeight)) {
/* 
 * de: Verkleinerungsfaktoren für vertikale und horizontale Ausdehnung berechnen.
 * en: Calculate scaling-factors for horizontal and vertical resolution. */
          double dblHorizontalScale = intImageWidth / intScrollPaneWidth;
          double dblVerticalScale = intImageHeight / intScrollPaneHeight;
/* 
 * de: Variable für die neue Größe des Images definieren.
 * en: Define variables for the new size of the image. */
          int intFinalImageWidth;
          int intFinalImageHeight;
/* 
 * de: Unterscheidung welche Dimension stärker verkleinert werden muss.
 * en: Decide which dimension needs mor shrinking. */
          if (dblHorizontalScale > dblVerticalScale) {
/* 
 * de:
 * Horizontal muss stärker verkleinert werden.
 * Neue Breite des Images ist die Breite des ScrollPane;
 * Höhe wird um den horizontalen Faktor verkleinert.
 * en:
 * Horizontal shrinking-factor is higher.
 * New width is the width of the ScrollPane; height is shrinked by the horizontal factor. */
            intFinalImageWidth = intScrollPaneWidth;
            intFinalImageHeight = intImageHeight * intScrollPaneWidth / intImageWidth;
          }
          else {
/* 
 * de:
 * Vertical muss stärker verkleinert werden; Algorithmus analog horizontaler Verkleinerung.
 * en:
 * Vertical shrinking-factor is higher; algorithm analog horizontal shrinking. */
            intFinalImageWidth = intImageWidth * intScrollPaneHeight / intImageHeight;
            intFinalImageHeight = intScrollPaneHeight;
          }
/* 
 * de: Originale Image verkleinert in die Variable dieser Klasse übernehmen.
 * en: Shrink original image during transfer to the variable of this class. */
          imgToBeDisplayed.setImage(pnl_Parent.imgFullResolution.getImage().getScaledInstance(
                intFinalImageWidth, intFinalImageHeight, Image.SCALE_SMOOTH));
        }
      }
/* 
 * de: Image anzeigen.
 * en: Display image. */
      this.setIcon(imgToBeDisplayed);
/* 
 * de:
 * Berechnen der Scroll-Units; das ist die Anzahl der Pixel um die das Image für einen
 * Impuls des Scrollrads der Maus verschoben wird.
 * Die Scroll-Units sind so bemessen, dass das Scrollen bei großen Images nicht 'ewig dauert'.
 * en:
 * Calculate the Scroll-Units; that is the number of pixel the image is moved for one impulse
 * of the scrollwheel of the mouse.
 * The scroll-units are calculated in a way, that scrolling large images does not 'take eternally'. */
      if (imgToBeDisplayed.getIconHeight() < 100) intScrollUnitIncrement = 1;
      else intScrollUnitIncrement = imgToBeDisplayed.getIconHeight() / 100;
/* 
 * de:
 * Wenn im Constructor des ScrollPane ein Parameter (Typ JLabel) für die Anzeige der Größe des
 * Images übergeben wurde dann wird in diesem jetzt die Original-Größe des Images angezeigt.
 * en:
 * If a parameter (of type JLabel) was passed as parameter in the constructor of the ScrollPane
 * then the original-size of the image is displayed in that parameter. */
      if (pnl_Parent.lbl_ImageInfoResolution != null) {
        String strResolutionInfo = pnl_Parent.imgFullResolution.getImage().getWidth(pnl_Parent) + " x " +
                                      pnl_Parent.imgFullResolution.getImage().getHeight(pnl_Parent);
        pnl_Parent.lbl_ImageInfoResolution.setText(strResolutionInfo);
      }
    }
/*
 * **************************************************
 * de:
 * Anschließend folgen Methoden die durch verschiedene Events ausgelöst werden.
 * Bei Methoden ohne detaillierte Beschreibung wurde der Code von Mustern kopiert.
 * Methoden die in den Event-getriggerten Methoden aufgerufen werden folgen nach den
 * Event-getriggerten Methoden.
 * en:
 * Following are the methods that are triggered by different events.
 * In methods without a detailled comment, the code was copied from samples.
 * Methods, that are called within event-triggered methods are implemented after the
 * event-triggered methods. */
/* 
 * de: METHODE zur Interface 'ActionListener'.
 * Diese Methode wird aufgerufen wenn ein Eintrag aus dem Popup-Menu (für 'Copy' und 'Paste')
 * mit der Maus ausgewählt wird.
 * en: METHOD belonging to the Interface 'ActionListener'.
 * This method is called when an entry of the popup-menu (for 'copy' and 'paste') is
 * selected with the mouse. */
    public void actionPerformed(ActionEvent e) {
/* 
 * de: Ermitteln von welchem Eintrag im Popup-Menu dieser Event ausgelöst wurde.
 * en: Determine which popup-menu-item triggered this event. */
      String cmd = e.getActionCommand().trim();
/* 
 * de: 'Copy' – Image in die Zwischenablage des Betriebssystems übertragen.
 * en: 'Copy' – transfer the image to the clipboard of the operating-system. */
      if (cmd.equals("mnu_Copy")) putImageToClipboard();
/* 
 * de: 'Paste' – Image aus der Zwischenablage des Betriebssystems holen und anzeigen.
 * en: 'Paste' – get the image from the clipboard of the operating-system and display it. */
      if (cmd.equals("mnu_Paste")) {
        pnl_Parent.imgFullResolution = new ImageIcon(getImageFromClipboard());
/* 
 * de:
 * Bytestream für das Image und Grafik-Format im Parent-Panel 'löschen' um zu signalisieren
 * dass beim Auslesen des Bytestreams dieser neu erstellt werden muss.
 * en:
 * 'Delete' the bytestream and the graphics-format in the parent-panel to signal that the
 * bytestream must be built new after a request to get ist. */
        pnl_Parent.strGraphicFormat = "";
        pnl_Parent.arrayImageAsBytes = new byte[0];
/* 
 * de: Gerade eingefügtes Image neu anzeigen.
 * en: Display the just pasted image. */
        setImage();
      }
    }
/* 
 * de: METHODE zur Interface 'ClipboardOwner'; kein spezifischer Code.
 * en: METHOD belonging to the Interface 'ClipboardOwner'; no specific Code. */
    public void lostOwnership(Clipboard parmClipboard, Transferable parmTransferable) {}
/* 
 * de: METHODE zur Interface 'MouseListener'.
 * Diese Methode wird aufgerufen wenn eine Maustaste geklickt (gedrückt und gleich wieder
 *  losgelassen) wird.
 * en: METHOD belonging to the Interface 'MouseListener'.
 * This method is called when a mouse-button is clicked (pressed and released immediately). */
    public void mouseClicked(MouseEvent e) {
/* 
 * de: Beim Klicken der linken Maustaste wird das Menu wieder entfernt.
 * en: The menu is removed when the left mouse-button is clicked. */
      if (e.getButton() == MouseEvent.BUTTON1) {
/* 
 * de:
 * Etwas komplizierter Code um das Popup-Menu wieder verschwinden zu lassen wenn
 * der Anwender keine Auswahl trifft.
 * Vielleicht geht es einfacher – habe aber nichts gefunden.
 * en:
 * A little bit complicated code to let the popup-menu diappear if the user does not
 * choose an item from the menu.
 * Maybe ther is an easier way – but I did not find it till now. */
        mnuCopyPaste.removeAll();
        mnuCopyPaste.setSize(0, 0);
        mnuCopyPaste = null;
/* 
 * de:
 * Zuletzt wird noch eine Bewegung mit dem Scrollrad der Maus simuliert damit die
 * vom Popup-Menu hinterlassene freie Fläche wieder durch den Teil des Images gefüllt wird.
 * en:
 * Finally, a movement with the scrollwheel of the mouse is simulated to redisplay
 * the part of the image that was covered by the popup-menu. */
        try {
          Robot tmpRobot = new Robot();
          tmpRobot.mouseWheel(1);
          tmpRobot.mouseWheel(-1);
        }
        catch (Exception Exc) {}
        this.repaint();
    
/* 
 * de: Methode beenden; damit wird das 'else' eingespart ;-).
 * en: End the method; that saves the 'else' ;-). */
        return;
      }
/* 
 * de:
 * Wenn eine andere als die 'linke' Maustaste geklickt wird:
 * Popup-Menu erstellen und mit den Auswahlmöglichkeiten füllen.
 * Eine Auswahlmöglichkeit wird aber nur angezeigt wenn der Text dafür nicht 'null' ist.
 * en:
 * If another mouse-button than the 'left' one is clicked:
 * Create the popup-menu and fill it with the selectable items.
 * A menu-item is only shown if the text to be displayed is not 'null'. */
      mnuCopyPaste = new JPopupMenu();
/* ***** */ 
      if (pnl_Parent.strMenuTextCopy != null) {
        JMenuItem itemCopy = new JMenuItem(pnl_Parent.strMenuTextCopy);
        mnuCopyPaste.add(itemCopy);
/* 
 * de:
 * Prüfen, ob ein Image angezeigt wird;
 * in diesem Fall den Menu-Eintrag für 'Copy' aktivieren und den Listener hinzufügen.
 * en:
 * Verify if an image is displayed;
 * in that case enable the menu-item 'copy' and add the Listener. */
        if (pnl_Parent.imgFullResolution != null) {
          itemCopy.setEnabled(true);
          itemCopy.addActionListener(this);
          itemCopy.setActionCommand("mnu_Copy");
        }
        else itemCopy.setEnabled(false);
      }
/* ***** */ 
      if (pnl_Parent.strMenuTextPaste != null) {
        JMenuItem itemPaste = new JMenuItem(pnl_Parent.strMenuTextPaste);
        mnuCopyPaste.add(itemPaste);
/* 
 * de:
 * Prüfen, ob ein Image im Clipboard des Betriebssystem vorhanden ist;
 * in diesem Fall den Menu-Eintrag für 'Paste' aktivieren und den Listener hinzufügen.
 * en:
 * Verify if an image is in the clipboard of the operating-system;
 * in that case enable the menu-item 'paste' and add the Listener. */
        if (getImageFromClipboard() != null) {
          itemPaste.setEnabled(true);
          itemPaste.addActionListener(this);
          itemPaste.setActionCommand("mnu_Paste");
        }
        else itemPaste.setEnabled(false);
      }
/* 
 * de: Popup-Menu an der Position des Mauszeigers anzeigen.
 * en: Display the popup-menu at the position of the mouse-pointer. */
      if ((pnl_Parent.strMenuTextCopy != null) || (pnl_Parent.strMenuTextPaste != null))
          mnuCopyPaste.show(e.getComponent(), e.getX(), e.getY());
    }
/* 
 * de: METHODEN zur Interface 'MouseListener'; kein spezifischer Code.
 * en: METHODS belonging to the Interface 'MouseListener'; no specific Code. */
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mousePressed(MouseEvent e) {}
    public void mouseReleased(MouseEvent e) {}
/* 
 * de: METHODE zur Interface 'MouseMotionListener'; kein spezifischer Code.
 * en: METHOD belonging to the Interface 'MouseMotionListener'; no specific Code. */
    public void mouseMoved(MouseEvent e) {}
/* 
 * de: METHODE zur Interface 'MouseMotionListener'.
 * Diese Methode wird aufgerufen wenn eine Maustaste niedergehalten ist und der Mauszeiger
 * bewegt wird. Ist der Mauszieger außerhalb des ScrollPane wird das Image 'gescrollt'
 * en: METHOD belonging to the Interface 'MouseMotionListener'.
 * This method is called when a mouse-button is hold down and the mouse-pointer is moved.
 * Is the mouse-pointer outside the ScrollPane then the image will be 'scrolled'. */
    public void mouseDragged(MouseEvent e) {
/* 
 * de:
 * Verwendeter Algorithmus:
 * Ein Rechteck des JLabels (mit dem Image) auswählen und das JLabel innerhalb des JScrollPane
 * so verschieben, dass das ausgewählte Rechteck im Sichtfenster des JScrollPane ist.
 * en:
 * Used algorithm:
 * Select a rectangle of the JLabel (containing the image) and move the JLabel within the JScrollPane
 * so that the rectangle is in the visible area of the JScrollPane. */
      Rectangle r = new Rectangle(e.getX(), e.getY(), 1, 1);
      scrollRectToVisible(r);
    }
/* 
 * de: METHODEN zur Interface 'Scrollable';
 * Diese Methoden passen die Scrollgeschwindigkeit bei Verwendung des Scrollrades auf der Maus
 * oder beim 'Mouse-Drag' an die Größe des Images an. Damit wird vermieden, dass es 'ewig dauert'
 * bis ein großes Image komplett verschoben ist.
 * Die Geschwindigkeit beim Scrollen wird durch die Variable 'intScrollUnitIncrement' bestimmt;
 * der Wert der Variable wird am Ende der Methode 'setImage()' berechnet.
 * Der Algorithmus wurde von einem Muster kopiert – deswegen fehlt eine Beschreibung.
 * en: METHODS belonging to the Interface 'Scrollable'; no specific Code.
 * These methods adapt the scrollspeed to the size of the image when the scrollwhel of the mouse o
 * r 'mouse-drag' is used. Adapting the scroll-speed prevents that scrolling of large images
 * 'takes eternally'.
 * The scroll-speed is controlled by the variable 'intScrollUnitIncrement'; the value of this variable
 * is calculated at the end of method 'setImage().
 * The algorithm was copied from an example; therefore a description is missing. */
    public Dimension getPreferredScrollableViewportSize() {
      return getPreferredSize();
    }
    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
      if (orientation == SwingConstants.HORIZONTAL) return visibleRect.width - 1;
      else return visibleRect.height - 1;
    }
    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
      int currentPosition = 0;
      if (orientation == SwingConstants.HORIZONTAL) currentPosition = visibleRect.x;
      else currentPosition = visibleRect.y;
      if (direction < 0) {
        int newPosition = currentPosition - (currentPosition / intScrollUnitIncrement) * intScrollUnitIncrement;
        return (newPosition == 0) ? intScrollUnitIncrement : newPosition;
      }
      else return ((currentPosition / intScrollUnitIncrement) + 1) * intScrollUnitIncrement - currentPosition;
    }
    public boolean getScrollableTracksViewportWidth() {return false;}
    public boolean getScrollableTracksViewportHeight() {return false;}
/*
 * ************************************************** */
/* 
 * de: METHODE zum Auslesen des Images aus dem 'Clipboard' (Zwischenabelege).
 * en: METHOD to read the image from the clipboard. */
    private Image getImageFromClipboard() {
/* 
 * de: Erstellen der Referenz auf die Zwischenablage des Betriebssystems.
 * en: Create a reference to the clipboard of the operating system. */
      final Clipboard clipboard = this.getToolkit().getSystemClipboard();
/* 
 * de: Zur Sicherheit prüfen ob auch die Referenz auf die Zwischablage auch existiert.
 * en: Verify for code-safety-reasons that the reference to the clipboard really exists. */
      if (clipboard == null) return null;
/* 
 * de: Auslesen des Inhalts aus der Zwischenablage.
 * en: Read the content of the clipboard. */
      Transferable clipData = clipboard.getContents(null);
/* 
 * de: Prüfen ob die Zwischenablage irgendeine Art von Daten enthalten hat.
 * en: Verify if the clipboard already contained any kind of data. */
      if (clipData == null) return null;
/* 
 * de: Prüfen ob die Daten in der Zwischenablage von anderer Art als 'Image' sind.
 * en: Verify if the data in the clipboard is o anothzer kind than 'image'. */
      if (! clipData.isDataFlavorSupported(DataFlavor.imageFlavor)) return null;
/* 
 * de:
 * Zwischenablage enthält ein 'Image'. Das Image auslesen – dazu ist die try-catch-Logik
 * notwendig um eventuell doch noch auftretende Fehler abzufangen.
 * en:
 * Clipboard contains an 'image'. Read out the image -use a try-catch-logic as a prevention
 * against possibly still existing mismatches. */
      try {
/* 
 * de:
 * Erstellen der Variable für den zurück gelieferten Wert;
 * Auslesen des Image aus der Zwischenablage und zurück liefern.
 * en:
 * Create the variable for the value to be returned; read the 'image' from the clipboard
 * and return the value. */
        Image imgToBeReturned = (Image) clipData.getTransferData(DataFlavor.imageFlavor);
        return imgToBeReturned;
      }
      catch (Exception Exc) {
/* 
 * de:
 * Image konnte nicht aus der Zwischenablage ausgelesen werden – 'null'-Wert zurück liefern.
 * en:
 * Image could not be read out of the clipboard; signal this by returning 'null'-value. */
        return null;
      }
    }
/* 
 * de: METHODE zum Einfügen des Images in das 'Clipboard' (Zwischenabelege).
 * en: METHOD to put the image to the clipboard. */
    protected void putImageToClipboard() {
/* 
 * de: Prüfen ob überhaupt ein Image in diesem Objekt vorhanden ist.
 * en: Verify if this object contains an image anyway. */
      if (pnl_Parent == null) return;
      if (pnl_Parent.imgFullResolution == null) return;
/* 
 * de: Erstellen der Referenz auf die Zwischenablage des Betriebssystems.
 * en: Create a reference to the clipboard of the operating system. */
      final Clipboard clipboard = this.getToolkit().getSystemClipboard();
/* 
 * de: Zur Sicherheit prüfen ob auch die Referenz auf die Zwischablage auch existiert.
 * en: Verify for code-safety-reasons that the reference to the clipboard really exists. */
      if (clipboard == null) return;
/* 
 * de:
 * Einfügen eines Images in die Zwischenablage ist nicht als Standard in Java implementiert.
 * Dafür ist eine Variable einer individuellen Klasse (anschließend an diese Methode implementiert)
 * notwendig.
 * en:
 * Inserting an image into the clipboard is not a standard implementation in Java.
 * It needs a variable of an individual class (implemented after this method). */
      ImageSelection imgSelection = new ImageSelection(pnl_Parent.imgFullResolution.getImage());
/* 
 * de: Transferieren des in der individuellen Klasse 'verpackten' Image in die Zwischenablage.
 * en: Transfer the image – 'wrapped' in the individual class – to the clipboard. */
      clipboard.setContents(imgSelection, null);
    }
/* 
 * de:
 * INTERNE KLASSE mit dem ein 'Image' 'Transferable' gemacht wird damit das 'Image'
 * in die Zwischenablage eingefügt werden kann.
 * en:
 * INTERNAL CLASS to make an 'Image' 'Transferable so that the 'Image' can be put to the clipboard. */
    private class ImageSelection implements Transferable {
/* 
 * de: Variable für das zu transferierende 'Image'.
 * en: Variable for the 'image' to be transferred. */
      private Image localImage;
/* 
 * de: 'Constructor' zur Übernahme des zu transferierende 'Image'.
 * en: 'Constructor' to take over the 'image' to be transferred. */
      public ImageSelection(Image parmImage) {
        localImage = parmImage;
      }
/* 
 * de: Überschreiben der Methoden der Klasse 'Transferable'.
 * en: Overwrite the methods of class 'Transferable'. */
      public DataFlavor[] getTransferDataFlavors() {
        return new DataFlavor[] {DataFlavor.imageFlavor};
      }
      public boolean isDataFlavorSupported(DataFlavor parmFlavor) {
        return DataFlavor.imageFlavor.equals(parmFlavor);
      }
      public Object getTransferData(DataFlavor parmFlavor) throws UnsupportedFlavorException, IOException {
        if (DataFlavor.imageFlavor.equals(parmFlavor)) return localImage;
        throw new UnsupportedFlavorException(parmFlavor);
      }
    }
  }
}

▲ zum Inhaltsverzeichnis

Erklärungen und Anwendungsbeispiele

Erstellen eines Objektes dieser Klasse

Zuerst muss eine Variable dieser Klasse definiert werden - eine detaillierte Beschreibung dazu finden Sie unter Muster-Code für die Klassen eines Task-Frame > Definieren der Variablen für die GUI-Elemente:
/*
 * Muster-GUI-Elemente;
 * Diese sind durch jene GUI-Elemente, die für diesen Task-Frame spezifisch sind,
 * zu ersetzen. */
. . . . . . .
. . . . . . .
    protected JSBS_ImagePane img_Sample_ImagePane;

Ein fehlersicherer Algorithmus ist, das Erstellen eines Objektes dieser Klasse innerhalb einer eigenen Methode auszuführen.
Das 'Verwenden' des Objektes dieser Klasse erfolgt durch den Aufruf der Methode – damit ist sicher gestellt, dass die Variable nicht 'null' sein kann.
Eine detaillierte Beschreibung dazu finden Sie unter Muster-Code für die Klassen eines Task-Frame > Adaptieren der 'Constructor'-Methoden für jedes GUI-Element.
Im folgenden Beispiel ist nur der minimal notwendige Code gezeigt – Erweiterungen für eine zusätzliche Funktionalität sind in den folgenden Abschnitten dokumentiert.
/* */
    protected JSBS_ImagePane get_img_Sample_ImagePane() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (img_Sample_ImagePane == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          img_Sample_ImagePane = new JSBS_ImagePane();
          img_Sample_ImagePane.setName("img_Sample_ImagePane");
/* 
 * Damit das Image in einer akzeptablen Größe angezeigt wird und nicht zu sehr schrumpfen kann
 * werden Grenzen für die Größe festgelegt. */
          img_Sample_ImagePane.setPreferredSize(new Dimension(400, 400));
          img_Sample_ImagePane.setMinimumSize(new Dimension(300, 300));
          img_Sample_ImagePane.setMaximumSize(new Dimension(1000, 500));
        }
        catch (Throwable Exc) {
/* Fehler beim 'construct' ist sehr unwahrscheinlich und kann nur beim 'Starten'
 * des Tasks auftreten.
 * Deswegen werden Fehlermeldungen nur auf der Konsole ausgegeben. */
          System.out.println("Error while building img_Sample_ImagePane in class application_task.");
          Exc.printStackTrace();
        }
      }
      return img_Sample_ImagePane;
    }

▲ zum Inhaltsverzeichnis

Zuordnen eines Objekts der Klasse 'JLabel' für die Anzeige der Image-Größe

Wenn notwendig kann beim 'konstruieren' eines Objekt der Klasse JSBS_ImagePane ein Objekt der Klasse JLabel als Parameter übergeben werden.
In diesem JLabel-Objekt wird die Größe des angezeigten Images als Text gesetzt.

. . . . . .
          img_Sample_ImagePane = new JSBS_ImagePane(get_lbl_ImageSize());
. . . . . .

Dieses JLabel-Objekt kann ebenfalls auf der GUI angezeigt werden; anschließend sehen Sie ein Beispiel:

▲ zum Inhaltsverzeichnis

Festlegen der Texte für das Kontext-Menu

Mit der Methode setLanguageSpecificMenuTexts(...) werden die Texte des Kontext-Menu (das beim Drücken und Halten der rechten Maustaste angezeigt wird) festgelegt.
. . . . . .
img_Sample_ImagePane.setLanguageSpecificMenuTexts(
            "Kopieren (in die Zwischenablage)",
            "Einfügen (aus der Zwischenablage)");
. . . . . .

Wenn Sie Ihre Anwendung nach dem JavaScout Fat-Client-Framework (JS-FCF) Vorgehensmodell entwickeln, können Sie die Texte für verschiedene Sprachen erfassen und innerhalb des Java-Codes einen symbolischen Namen verwenden.
. . . . . .
img_Sample_ImagePane.setLanguageSpecificMenuTexts(
            frmCC.structJSBS_XML_DisplayStrings.getSupplementaryText("MenuItem_CopyToClipboard"),
            frmCC.structJSBS_XML_DisplayStrings.getSupplementaryText("MenuItem_PasteFromClipboard"));
. . . . . .

Wird in einem Parameter der Wert null übergeben dann wird der entsprechende Eintrag des Kontext-Menus nicht angezeigt.

Die Auswirkungen verschiedener Parameter-Kombinationen sehen Sie anschließend:

Weitere Möglichkeiten zur Steuerung finden Sie im Abschnitt Erklärungen und Anwendungsbeispiele.

▲ zum Inhaltsverzeichnis

Reagieren auf eine Änderung des angezeigten Images

Mit dem hier beschriebenen Code kann ein Einfügen eines Images über die 'Paste'-Auswahlmöglichkeit des Kontext-Menus erkannt werden.
. . . . . .
          img_Sample_ImagePane.addPropertyChangeListener(new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent evt) {
/* Aufrufen der Methode, die das Image weiter bearbeitet. */
              application_task__ActionHandler.processChangedImage(this);
            }
          });
. . . . . .

Der Platzhalter application_task__ActionHandler.processChangedImage(this) ist durch den Aufruf einer Methode zu ersetzen, in der die Verarbeitungen entsprechend der Anforderungen codiert werden.
In dieser Methode wird üblicherweise die Vorbereitung für das Speichern des eingefügten Images auf der Datenbank ausgeführt.
Weiters können darin auch Schaltflächen aktiviert werden.

▲ zum Inhaltsverzeichnis

Transferieren des Images in das / aus dem JSBS_ImagePane

Das Anzeigen eines Images erfolgt durch den Aufruf der Methode
img_Sample_ImagePane.setImage(Variable_containing_Image_as_Bytestream, String_With_Graphic_Format)
Dabei werden das Image in Form eines Bytestream (Array vom elementaren Typ byte[]) und das Grafik-Format (von der Klasse String) übergeben.
Diese Methode ist besonders geeignet wenn wenn das anzuzeigende Image aus einer Datei oder einer Datenbank (Attributstyp BLOB / Binary Large OBject) ausgelesen wurde.
Hinweis:
Es erfolgt innerhalb dieser Klasse (JSBS_ImagePane) keine Prüfung, ob das, als eigener Parameter übergebene, Grafik-Format auch dem Aufbau des Bytestreams des Image entspricht.
Beim Auslesen des Images (Methode img_Sample_ImagePane.getImageAsByteArray()) wird der Bytestream im gleichen Grafik-Format zurück gegeben wie er mit dieser Methode übergeben wurde.