CIB JView technischer Leitfaden

Einführung: CIB jView mit Rich-Text-Edit-Komponente

Allgemein
 CIB jView mit jRec
 CIB jView mit jRec2
 Steuerung des Verhältnisses von jView-Fenster zu Edit-Fenster
 Interface SplitPaneListener mit Callback-Methode für Split-Panel
 Interface PushAreaListener mit Callback-Methode für Edit-Bereiche
 Kennzeichenersetzung in RTF-Dokumenten
Allgemein

CIB jView steht auch mit den zusätzlichen Komponenten jRec bzw. jRec2 zur Verfügung und wird dann als jView&jRec bzw JView&jRec2 bezeichnet. CIB jRec und jRec2 sind Java basierte Rich-Text Editor-Komponente, die sich nach dem von anderen CIB Modulen bekannten Schnittstellenkonzept einfach in Masken und fremde Anwendungen integrieren lässt.  Durch ihre Integration in jView ist es möglich, bei RTF-Dokumenten, die ein oder mehrere editierbare Felder enthalten, deren Inhalt in einem separaten Fenster zu bearbeiten. Editierbare Bereiche werden durch Rechtecke mit gestrichelter Umrandung dargestellt.

Die CIB Rec-Editoren können entweder leer, mit ASCII oder RTF-Texten gestartet werden. Umgekehrt können die Texte wieder im ASCII- oder RTF-Format aus dem Edit-Control gelesen werden.

Falls im CIB jView mit Rec-Komponente ein RTF-Dokument mit eingebetteten Edit-Feldern angezeigt ist, öffnet sich durch Doppelklick in einen Editbereich unterhalb des Viewer-Fensters ein Edit-Fenster, in dem der aktuelle Text angezeigt wird und bearbeitet werden kann. Der jeweils in Bearbeitung befindliche Bereich wird im Viewer-Fenster rot umrandet dargestellt.

Durch erneuten Doppelklick in das Viewer-Fenster, diesmal außerhalb des Edit-Feldes, wird der geänderte Text in das Dokument übernommen und das Edit-Fenster wieder geschlossen. Alternativ dazu kann die Bearbeitung durch Klick auf das Beenden-Icon ganz rechts in der Toolleiste des Edit-Fensters beendet werden. Dabei erscheint ein Dialog mit der Frage, ob die Änderungen über­nommen werden sollen oder nicht.

Falls das JView-Paket  die jRec2-Bibliotheken enthält, wird im Edit-FensterCIB jRec2 gestartet, falls nur die jRec-Bibliotheken enthalten sind, wird CIB jRec gestartet. Falls keine der Rec-Bibliotheken im JView-Paket enthalten ist, können Rec-Bereiche im JView nicht  geöffnet und editiert werden.

CIB jRec2 ist eine komplette Neuentwicklung und umfasst weitaus mehr Funktionen als CIB jRec. Wie die anderen CIB Module können dieses RTF-Edit-Controls komfortabel durch Setzen verschiedener Properties gesteuert werden.

Im Folgenden werden die beiden Komponenten kurz beschrieben. Detaillierte Beschreibungen finden Sie in den Technischen Leitfäden zu den beiden Produkten.


CIB jView mit jRec

CIB jRec besitzt folgende Möglichkeiten zur Textformatierung:

  • Verschiedene Schriftarten und Schriftgrößen
  • Zeichenattribute fett, kursiv, unterstrichen, farbig
  • Absatzausrichtung linksbündig, zentriert, rechtsbündig
  • Kopieren, Ausschneiden und Einfügen markierter Textabschnitte
  • Ein-/Ausblenden von Formatierungszeichen


CIB jView mit jRec2

Der CIB jRec2 umfasst folgende Funktionalitäten:

  • Verschiedene Schriftarten und Schriftgrößen
  • Zeichenattribute fett, kursiv, unterstrichen, farbig, durchgestrichen, hochgestellt, tiefgestellt
  • Absatzausrichtung linksbündig, zentriert, rechtsbündig, Blocksatz
  • Kopieren, Ausschneiden und Einfügen markierter Textabschnitte
  • Ein-/Ausblenden von Formatierungszeichen
  • Öffnen und Speichern von RTF-Dokumenten
  • Einfügen von Plain-Text und RTF-Text über API-Funktionen
  • Mehrere Dokumentseiten
  • Anzeige der Text-Hintergrundfarbe
  • Aufzählungen
  • Nummerierte Listen
  • Ein-/Ausrückungen von Listen
  • Tabellen mit Formatierungen für Tabellenzeile, Tabellenspalte und Tabellenzelle
  • Rahmen und Hintergrund für ganze Tabelle bzw. einzelne Zellen
  • Automatische Silbentrennung
  • Rechtschreibprüfung
  • Wörterbuch


Steuerung des Verhältnisses von jView-Fenster zu Edit-Fenster

Bei geöffnetem Editbereich ist der Anzeigebereich des Anwendungsfensters durch ein Split-Panel in ein jView-Fenster (Viewing-Bereich) und ein Edit-Fenster (=Editbereich) unterteilt.  Ein Edit-Fenster kann entweder ein jRec- oder ein jRec2-Edit-Control enthalten. Standardmäßig ist das Verhältnis zwischen JView- und Edit-Fenster 2:1, das JView-Fenster nimmt also 66% des Anzeigebereichs ein.

Um dieses  Verhältnis von der aufrufenden Anwendung steuern zu können, wird eine Integer-Property PROPERTY_SPLITPANE_DIVIDER_PERCENTAGE (= „splitpane-divider-percentage”) eingeführt, die den prozentualen Anteil des JView-Fensters zum gesamten Anzeigebereich bei geöffnetem Editbereich angibt.

Diese Property wird beim Aufruf von jView wie die anderen Properties bei der jView-Instanz gesetzt und beim Öffnen des Edit-Fensters ausgewertet.

Code-Beispiel zum Setzen des SplitPane-Verhältnisses  bei der jView-Instanz (Verhältnis jView-Fenster zu Gesamt-Fenster in Prozent, der Defaultwert ist 66 Prozent): 

      // Beim Start von jView
      t_CibView.setProperty(
            ICibApplication.PROPERTY_SPLITPANE_DIVIDER_PERCENTAGE,
            new Integer(50));


Interface SplitPaneListener mit Callback-Methode für Split-Panel

Zusätzlich zum Setzen der Property wird ein Interface SplitPaneListener mit einer CallBack-Methode splitDividerPercentage eingeführt, die den aktuellen Prozentwert zurückliefert. Der Aufrufer muss sich dazu bei der JView-Instanz als Listener anmelden.

Bei der Registrierung kann durch ein bitcodiertes Flag angegeben werden, bei welchen Ereignissen der Listener informiert werden soll:

  • Bei jedem Schließen des Edit-Bereiches
  • Beim Beenden der jView-Applikation

Beim Eintreten des Ereignisses wird jeder registrierte Listener über den aktuellen Prozentwert informiert.

So kann der Aufrufer selbst entscheiden, wo und wie er diese Information abspeichert (lokal oder in der Datenbank, benutzer- oder anwendungsspezifisch).

 Die Interface-Definition für die Callback-Methode ist in CIB gui (package de.cib.gui.event) definiert.

 package
de.cib.gui.event;
 /** 
 * Interface SplitPaneListener
 *
 * This interface is used to listen to changes of split pane settings.
 * 
 */
public interface SplitPaneListener {
 
      /**
       * Send a divider info when jRec is closed.
       * Value 0x1 (bit-coded)
       */
      public static final int DIVIDER_INFO_ON_JREC_CLOSE = 0x1;
      /**
       * Send a divider info when JView is closed.
       * Value 0x2 (bit-coded)
       */
      public static final int DIVIDER_INFO_ON_JVIEW_CLOSE = 0x2;
 
      /**
       * Call back for split pane divider percentage.
       * @param splitPercentage
       */
      public void splitDividerPercentage(int splitPercentage);
 }

 Code-Beispiel zum Anmelden / Abmelden als SplitPaneListener bei der jView-Instanz:

       // Definition eines RecPaneListeners
    static class RecPaneListener implements SplitPaneListener {
            public void splitDividerPercentage(int splitPercentage) {
                  
                  Trace.traceln("SplitPane divider percentage = "
                   + splitPercentage);
            }
    }
      RecPaneListener recPaneListener = new RecPaneListener(),
             SplitPaneListener.DIVIDER_INFO_ON_JREC_CLOSE |
             SplitPaneListener.DIVIDER_INFO_ON_JVIEW_CLOSE);
 
      // Beim Start von jView
      t_ CibView.addSplitPaneListener(recPaneListener);
      ...
 
      // Beim Beenden von jView
 t_CibView.removeSplitPaneListener(recPaneListener);

 

Beim Auftreten eines der oben definierten Events wird die Callback-Methode des registrierten SplitPane-Listeners mit dem aktuellen Prozentwert aufgerufen.

      // Beim Schließen von jRec bzw. Beenden von jView
 recPaneListener.splitDividerPercentage(splitPercentage);

 

Interface PushAreaListener mit Callback-Methode für Edit-Bereiche

Für die Überwachung der Editbereiche wird ein Interface PusAreaListener mit einer CallBack-Methode pushAreaChanged zur Verfügung gestellt, die den registrierten Listener über Änderungen bei den Editbereichen informiert. Der Aufrufer muss sich dazu bei der jView-Instanz als PushAreaListener anmelden.

Es gibt verschiedene Ereignisse, über die der Listener informiert wird:

  • Bevor sich die aktive PushArea ändert, also bevor eine neue PushArea geöffnet oder  eine geöffnete PushArea geschlossen wird.
  • Ob sich der Inhalt eine PushArea nach dem Schließen des Editbereichs geändert hat.
  • Nachdem die aktive PushArea geschlossen wurde und alle Änderungen im JView abgeschlossen sind.

Beim Eintreten eines Ereignisses wird der registrierte Listener über die aktuellen Werte informiert.

Die Interface-Definition für die Callback-Methode ist in CIB jView (package de.cib.view.ui) definiert. 

package de.cib.view.ui;
 
import java.beans.PropertyChangeEvent;
 
/**
 *
Interface PushAreaListener
 *
 * This interface is used to listen to changes of activated push areas.
 * 
 */ public interface PushAreaListener {
 
      public void pushAreaChanged(PropertyChangeEvent event);
 
}

 

Code-Beispiel eines PushAreaListeners:

 // Definition JRecListener als PushAreaListener
static class JRecListener implements PushAreaListener {
 
      public void pushAreaChanged(PropertyChangeEvent evt) {
            String property = evt.getPropertyName();
            Trace.traceln("START PUSHAREA EVENT --- " + property);
            if (JCibViewUI.PROPERTY_CHANGE_ACTIVE_PUSHAREA
                        .equals(property)) {
                  if (evt.getOldValue() != null) 
                        Trace.traceln(">>>>> Rec-Field was closed: " 
                              + evt.getOldValue());
                  if (evt.getNewValue() != null) 
                        Trace.traceln(">>>>> Rec-Field was opened: "     
                              + evt.getNewValue());
            }
            else if (JCibViewUI.ACTIVE_PUSHAREA_CONTENT_CHANGED
                        .equals(property)) {
                  if (evt.getNewValue() != null 
                  && ((Boolean) evt.getNewValue()))
                        Trace.traceln(">>> Document content is changed.");
                  else 
                        Trace.traceln(">>> Document content is NOT changed.");
            }
            else if (JCibViewUI.PROPERTY_FINISH_ACTIVE_PUSHAREA
                        .equals(property)) {
                  if (evt.getOldValue() != null && evt.getOldValue() 
                        instanceof de.cib.metafile.RichEditControl) {
                        // Check if rec snippet has been changed
                      de.cib.metafile.RichEditControl richEditControl 
                        = (de.cib.metafile.RichEditControl)evt.getOldValue();
                              Trace.traceln("RTF edit field_" 
                                    + richEditControl.getFormFieldID() 
                                    + " is merged and reloaded.");
                              Trace.traceln("RTF snippet text:\n" 
                                    + richEditControl.getRtfPassage(""));
                  }
            }
            Trace.traceln("END PUSHAREA EVENT --- " + property);
      }
}

 Code-Beispiel zum Anmelden / Abmelden als PushAreaListener bei der jView-Instanz:

       // Beim Start von jView
      JRecListener m_RecListener = new JRecListener();
      t_CIBView.addPushAreaListener(m_RecListener);
      t_CIBView.start();
      ...
 
      // Beim Beenden von jView
      t_CibView.removePushAreaListener(m_RecListener);
      t_CIBView.stop();

Kennzeichenersetzung in RTF-Dokumenten

Es ist möglich, ein oder mehrere in einem RTF-Dokument enthaltene Revisionskennzeichen, die mit einem bestimmten Wert vorbelegt sind, nach der Änderung eines Editierbereichs mit neuen Werten zu belegen.

Dazu wird an die JView-Instanz eine Liste (Map) von ID/Value-Paaren übergeben, wobei jedes Element die ID des Revisionskennzeichens und den zugehörigen neuen Wert enthält.

Falls ein RTF-Dokument im jView geöffnet ist und ein Editierbereich in diesem Dokument geändert wird, wird über CIB merge der geänderte Inhalt des Editierbereichs in das Dokument eingemischt. Gleichzeitig wird dabei für jede ID aus der übergebenen Liste in dem entsprechenden Feld der alte durch den neuen Wert ersetzt.

Dazu gibt es im Interface ICibView, das von JCibView implementiert wird, die folgende Methode:

/**
 * Sets the replacement values on changing the current RTF document.
 * If a RTF document is changed each given id is replaced by the matching value.
 * 
 * @param rtfIdValues  the Map with id/value pairs
*/
public void setReplacementsOnRtfChange(Map<String, String> rtfIdValues);

 

Die Anwendung, die den JView bei sich einbettet, kann die Liste der ID/Value-Paare analog zum folgenden Code-Beispiel bei der JView-Instanz setzen: 

        JCibView t_CIBView = new JCibView();
       ...
       // Set map with RTF id/value pairs to change for test purpose
       HashMap<String, String> rtfIdValues = new HashMap<String, String>();
       rtfIdValues.put("REVID", "ID1a");
       rtfIdValues.put("USERID", "ID2b");
       t_CIBView.setReplacementsOnRtfChange(rtfIdValues);
       ...
       t_CIBView.start();
       t_CIBView.load();