CIB JView technischer Leitfaden

Lieferumfang

Allgemein

CIB JView steht in verschiedenen Varianten mit unterschiedlichem Funktionsumfang zur Verfügung. Die Applikation wird in Form einer zip-Datei angeliefert.

Nach dem Auspacken ergibt sich folgende Verzeichnisstruktur mit den angegebenen Dateien, wobei zwischen den Varianten für Windows und Linux unterschieden werden muss.

CIB JView für Windows

CIB JView für Linux

Benutzung von JComod-IPC

Wird JComod-IPC zusammen mit Webstart auf einem Windows Vista System ausgeführt, muss darauf geachtet werden, dass alle für die Applikation notwendigen Dateien in einem Verzeichnis gespeichert werden, welches kein Integrity gesetzt hat. Hintergrund ist der unter Windows Vista verwendete Integrity-Mechanismus zur Einschränkung der Rechte für Applikationen.

Einführung: CIB JView

CIB jView ist ein flexibler Dokument-Viewer für RTF-, PDF-, ASCII- und Image-Dateien. Er benutzt intern native Aufrufe der CIB office Module über den JCoMod Wrapper und dessen Jobklassen.

Die Oberfläche des CIB jView umfasst folgende Komponenten:

• Menüleiste
• Toolbarleiste
• Viewer-Fenster mit Scrollbar
• Seiten-Navigationsleiste
• Statuszeile

Sie lässt sich über eine Methode zum Setzen von Properties (cibView.setProperty), frei nach den Wünschen der aufrufenden Applikation gestalten. Jede einzelne graphische Komponente (z.B. Toolbar-Icon), die auf dem Bild zu sehen ist, kann durch Setzen der entsprechenden Property aus- oder eingeschaltet werden. Die dazugehörigen Eigenschaften sind als Member in der Schnittstelle de.cib.gui.framework.ICibApplication aufgelistet.

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

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.

• Technischer Leitfaden CIB jRec
• Technischer Leitfaden CIB jRec2

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();

Einführung: Anbindung an Korrespondenzsystem - jView&coSys

Allgemein

In CIB jView sind auch Funktionen zur Anbindung an das Korrespondenzsystems CIB webdesk 2.0 integriert. Diese JView-Erweiterung wird als JView&coSys bezeichnet.

Dazu sind verschiedene Interfaces definiert, die in den folgenden Abschnitten beschrieben werden.

Interface AuthenticationCallback mit Callback-Methode für die Authentifizierung

Zur Authentifizierung bei CIB webdesk bzw. darkdesk wird ein Interface AuthenticationCallback mit einer CallBack-Methode getStarterTicket() eingeführt, die das aktuelle Starterticket zurückliefert. Der Aufrufer muss sich dazu bei der JView-Instanz als Listener anmelden.

Das Interface AuthenticationCallback ist im CIB jView (package de.cib.view.correspondence) definiert.

package de.cib.view.correspondence;
 
/**
 * Interface AuthenticationCallback
 *
 * This interface is used to listen to authentication events.
 * 
 */
public interface AuthenticationCallback {
 
      /**
       * Call back for getting a starter ticket.
       * @return a starter ticket
       */
      public String getStarterTicket();
 }

Code-Beispiel zum Setzen eines AuthenticationCallback Listeners bei der jView-Instanz:

       // Definition eines AuthenticationCallback Listeners
      static String clientID = null;
 
      static class AuthenticationCallbackTester 
                  implements AuthenticationCallback
{
 
            public String getStarterTicket() {
                  // For test with mock service
                  String starterTicket = null;
                  if (clientID != null)
                        starterTicket = "start" + clientID;
                  return starterTicket;
            }
      }
 
      // Beim Start von jView
 t_CibView.setAuthenticationCallback(
            new AuthenticationCallbackTester());
      ...
 
      // Beim Beenden von JView
 t_CibView.setAuthenticationCallback(null);

Interface ApprovalCallback mit Callback-Methoden für die Freigabe

Für Freigabe von Korrespondenz-Dokumenten im CIB webdesk bzw. darkdesk wird ein Interface ApprovalCallback mit den CallBack-Methoden workflowApprovalCommitted() und workflowApprovalDenied() eingeführt, die den Listener darüber informieren, ab die Freigabe erfolgreich durchgeführt oder abgebrochen wurde. Der Aufrufer muss sich dazu bei der JView-Instanz als Listener anmelden.

Das Interface ApprovalCallback ist im CIB jView (package de.cib.view.correspondence) definiert.

package de.cib.view.correspondence;
 
/**
 * Used to allow JView callbacks to the instantiating application
 * in case of workflow approvals. 
 * 
*/
public interface ApprovalCallback {
      
      /**
       * This method is called when a user approves the current
       * viewed document.<br>
       * Override this method to implement specific handling of
       * this callback.
       */
      void workflowApprovalCommitted();
      
      /**
       * This method is called when a user denies approval of the current
       * viewed document.<br>
       * Override this method to implement specific handling of
       * this callback.
       */
      void workflowApprovalDenied();
}

 Code-Beispiel zum Setzen eines ApprovalCallback Listeners bei der jView-Instanz:

       // Definition eines ApprovalCallback Listeners
      static String clientID = null;
 
      static class ApprovalCallbackTester implements ApprovalCallback {
            public void workflowApprovalCommitted() {
                  JCibTrace.info("CALLBACK - workflowApprovalCommitted()");
            }
      
            public void workflowApprovalDenied() {
                  JCibTrace.info("CALLBACK - workflowApprovalDenied()");
            }
      }
 
      // Beim Start von JView
  t_CibView.setApprovalCallback(new ApprovalCallbackTester());
      ...
 
      // Beim Beenden von JView
 t_CibView.setApprovalCallback(null);

Interface WorkflowListener mit Callback-Methoden für den Workflow

Für den Workflow von Korrespondenz-Dokumenten im CIB webdesk bzw. darkdesk wird ein Interface WorkflowListener mit verschiedenen CallBack-Methoden eingeführt, die den Listener darüber informieren, welche Benutzereingaben im Workflow für das aktuelle Korrespondenz­dokument erfolgt sind. Der Aufrufer muss sich dazu bei der JView-Instanz als Listener anmelden.

Das Interface WorkflowListener ist im CIB jView (package de.cib.view.correspondence) definiert.

package de.cib.view.correspondence;
 
/**
 * Interface WorkflowListener
 *
 * This interface is used to listen to workflow events.
 * 
 */
public interface WorkflowListener {
 
      /**
       * Call back for accept.
       * @param 
       */
      void onAccept();
 
      /**
       * Call back for reject.
       * @param 
       */
      void onReject();
 
      /**
       * Call back for accept and approve.
       * @param 
       */
      void onAcceptAndApprove();
 
      /**
       * Call back for restart workflow.
       * @param 
       */
      void onRestartWorkflow();
 }

Code-Beispiel zum Setzen eines Workflow Listeners bei der jView-Instanz:

      // Definition eines Workflow Listeners
      static class WorkflowCallbackTester implements WorkflowListener {
                  public void onAccept() {
                  System.out.println("Called workflowOnAccept()");
            }
      
            public void onReject() {
                  System.out.println("Called workflowOnReject()");
            }
      
            public void onAcceptAndApprove() {
                  System.out.println("Called workflowOnAcceptAndApprove()");
            }
      
            public void onRestartWorkflow() {
                  System.out.println("Called workflowOnRestartWorkflow()");
            }
      }
 
      // Beim Start von jView
      final WorkflowCallbackTester workflowListener = 
                  new WorkflowCallbackTester();
t_CibView.addWorkflowListener(workflowListener);
      ...
 
      // Beim Beenden von jView
t_CibView.removeWorkflowListener(workflowListener);

Einführung: CIB JPrintDialog

Beim Drucken eines Dokumentes aus dem JView heraus wird standardmäßig die Komponente JPrintDialog verwendet. Wenn der native Java Drucker-Dialog verwendet werden soll, muss die Property ICibApplication.PROPERTY_SHOWJPRINTDIALOG auf FALSE gesetzt werden.

Mit den Komponenten JView und dem JPrintDialog verfügt die Palette der CIB office Module (CoMod) über pure Java GUI Komponenten, die sich in beliebige Java-Anwendungen und Frameworks integrieren lassen.

Intern benutzen diese Module über den JCoMod-Wrapper (JNI) z.T. noch spezielle Dienste nativer CIB Komponenten im Hintergrund.

JView und der JPrintDialog basieren auf der Swing-GUI und sind ab JDK-Version 1.4.2 einsetzbar.

Die vorliegende Dokumentation gibt einen Überblick über technische Schnittstellen, Aufrufparameter und Eigenschaften der CIB jView Komponente und enthält konkrete Einsatzbeispiele.

Detaillierte technische Schnittstellen entnehmen Sie bitte der Javadoc-Beschreibung.

Konfiguration durch Properties

Konfiguration durch Properties

Allgemeine Properties

Mit den folgenden Properties können generelle Einstellung für die Applikation gesetzt werden.

Properties zur Konfiguration der Menüleiste

Mit den folgenden Properties kann die gesamte Menüleiste oder einzelne Menüs aus- oder eingeschaltet werden. Setzen der Property auf TRUE bewirkt, dass die Menüleiste bzw. das Menü sichtbar und aktiv ist, FALSE bedeutet, das Element ist unsichtbar und deaktiviert.

Properties zur Konfiguration der Toolbar

Die folgende Property dient zur Positionierung der Toolbar.

Mit den folgenden Properties können einzelne Elemente der Toolbar oder die gesamte Toolbar aus- oder eingeblendet werden. Setzen der Property auf TRUE bewirkt, dass das Element sichtbar und aktiv ist, FALSE bedeutet, das Element ist unsichtbar und deaktiviert.

Properties zur Konfiguration der Navigationsfelder

Mit den folgenden Properties können die einzelnen Elemente der Seiten-Navigationsfelder aus- oder eingeblendet werden. Setzen der Property auf TRUE bewirkt, dass das Element sichtbar und aktiv ist, FALSE bedeutet, das Element ist unsichtbar und deaktiviert.

Properties zur Konfiguration der Statuszeile

Mit den folgenden Properties können einzelne Elemente der Statuszeile oder die gesamte Statuszeile aus- oder eingeblendet werden. Setzen der Property auf TRUE bewirkt, dass das Element sichtbar und aktiv ist, FALSE bedeutet, das Element ist unsichtbar und deaktiviert.

Properties zur Konfiguration von CIB jView&coSys

Mit den folgenden Properties können die Korrespondenzfunktionen von CIB jView&coSys konfiguriert werden.

Properties zur Konfiguration des CIB jRec Edit-Controls

Die folgende Property zeigt an, ob das CIB jRec Edit-Control innerhalb von JView aktivierbar ist oder nicht.

  // JRec-Instanz holen ohne zu   starten
  JCibApplication t_CibRec = t_CibView.getRec(false);
  if (t_cibRec instanceof JCibRec) {
    System.out.println("CIB jRec is   active.");
  }
  else   if (t_cibRec instanceof JCibRec2) {
    System.out.println("CIB jRec2 is   active.");
  }

Die nächste Property bestimmt das Verhältnis zwischen jView-Fenster und Editbereichs-Fenster.

Die folgende Property bestimmt, in welchem Zoom-Modus das Editbereichs-Fenster geöffnet wird.

Die folgende Property bestimmt, ob beim Schließen des Anwendungsfensters, in das der JView eingebettet ist, eine Abfrage erscheint, ob das geänderte Dokument gespeichert werden soll.
Die Property steuert auch eine eventuelle Abfrage, ob die Änderungen übernommen werden sollen, falls gerade ein Rec-Editbereich bearbeitet wird und dann das Anwendungsfenster geschlossen wird.

Die folgenden Properties bestimmen, ob namensgleiche Editbereiche bei Änderung eines Editbereichs mit demselben Inhalt gefüllt werden sollen, und ob ein Warnhinweis angezeigt wird, wenn ein Editbereich geändert wurde und namensgleiche Editbereiche dadurch ebenfalls geändert wurden.

Die folgenden Properties bestimmen, ob und mit welcher transparenten Hintergrund­farbe Editbereiche im JView angezeigt werden. Es gibt eine Property, mit der die Anzeige der Hintergrundfarbe aktiviert wird. Außerdem kann die Hintergrundfarbe für die Editbereiche im normalen und im aktivierten Zustand durch zwei weitere Properties getrennt angegeben werden.

Alle weiteren jRec-Properties müssen direkt bei der jRec-Instanz gesetzt werden. Mit ihnen kann das Verhalten des eingebetteten jRec Edit-Controls gesteuert werden. Dazu muss über die jView-Instanz eine jRec-Instanz geholt werden. Siehe dazu den Beispielcode bei der Beschreibung der Property PROPERTY_JREC_INIFILENAME.

  // JRec-Instanz
  holen ohne zu starten
  JCibApplication t_CibRec = t_CibView.getRec(false);
  if (t_CibRec != null) {
    //
  Keine JRec Ini-Datei schreiben
    t_CibRec.setProperty(ICibRecApplication.PROPERTY_JREC_INIFILENAME,
      null);
  }

Properties zur Konfiguration des CIB jScan Controls

Die folgende Property zeigt an, ob das CIB jScan Control innerhalb von jView aktivierbar ist oder nicht.

Alle weiteren jScan-Properties müssen bei der jView-Instanz gesetzt werden. Dies ist notwendig, da bei jedem Öffnen des Scan-Panels eine Instanz der Scan-Applikation CIB jScan erzeugt wird, an die diese Properties übertragen werden. Mit ihnen kann das Verhalten des eingebetteten jScan-Controls gesteuert werden.

Die Beschreibung aller Properties für CIB jScan finden Sie im Dokument TechnischerLeitfadenCIBjScan.pdf

Properties zur Aktivierung und Konfiguration von CIB jView&form

Die folgende Property legt fest an, ob die Bearbeitung von Formularen innerhalb von jView möglich ist oder nicht.

Alle weiteren Form-Properties können ebenfalls bei der JView-Instanz gesetzt werden. Mit ihnen kann das Verhalten der Formular-Komponente gesteuert werden.

Die Beschreibung aller Properties für CIB jView&form finden Sie im Dokument TechnischerLeitfadenCIBjViewform.pdf

Properties zur Aktivierung und Konfiguration von CIB jView&sign

Die folgende Property legt fest an, ob die elektronische Signatur von Formularen innerhalb von JView möglich ist oder nicht.

Alle weiteren Sign-Properties können ebenfalls bei der JView-Instanz gesetzt werden. Mit ihnen kann das Verhalten der Signatur-Komponente gesteuert werden.

Die Beschreibung aller Properties für CIB jView&sign finden Sie im Dokument TechnischerLeitfadenCIBjViewsign.pdf

Batch-Dateien zum Starten des Viewers

Nach der Installation des JView-Pakets unter Windows (Auspacken der zip-Datei) stehen im Verzeichnis CibjView die folgenden Batch-Dateien zum Starten des jView zur Verfügung:

• run.bat                  Startet den jView ohne JComod-IPC
• run_ipc-bat Startet den jView mit JComod-IPC

 Voraussetzung für die Ablauffähigkeit des jView ist:

• JRE6 oder JDK6 oder neuere Java-Versionen sind installiert
• Die System-Umgebungsvariable JAVA_HOME zeigt auf die Java-Installation, etwa
• JAVA_HOME=C:\Programme\Java\jre6 (unter Windows XP und Vista)
• JAVA_HOME=C:\Program Files (x86)\Java\jre6 (unter Windows7 - 64bit)
• Alternativ dazu kann auch ganz oben in der Batch-Datei der Pfad auf das JAVA_HOME Verzeichnis gesetzt werden:
• set JAVA_HOME=C:\Programme\Java\jre6 (unter Windows XP und Vista)
• set JAVA_HOME=C:\Program Files (x86)\Java\jre6 (unter Windows7 - 64bit)

Steuerung durch Aufrufparameter

CIB jView kann auch durch Aufrufparameter in der Batch-Datei (run.bat bzw. run.sh) gesteuert werden.

Dabei gilt die übliche Syntax für Kommandozeilenparameter:

-<Parametername-1> <Parameterwert-1> … -<Parametername-n> <Parameterwert-n>

Die Namen der Parameter entsprechen den internen Namen der Properties. Falls nicht bekannt, können sie durch den Support erfragt werden.

Zusätzlich gibt es folgende Aufrufparameter:

<Dateiname>                Name des Dokuments, das beim Start der Applikation geladen werden soll (ohne vorausgehendes Minuszeichen)

-t                                   Aktiviert die Ausgabe von Trace-Informationen in die Konsole

-tracefile <Dateiname> Aktiviert die Ausgabe von Trace-Informationen in die angegebene Datei

-traceLevel <Level>       Setzt das Trace-Level auf den angegebenen Wert
(mögliche Werte sind ERROR | WARN | INFO | DEBUG | DEBUGALL)

Für die Java Virtual Machine (JVM) müssen die folgenden Properties (VM-Parameter) gesetzt werden:

Java Library-Pfad           -Djava.library.path=lib/win32 (bei Windows)
-Djava.library.path=lib/linux32 (bei Linux)

JAI-Bibliotheken            -Dcom.sun.media.jai.disableMediaLib=true (muss = true gesetzt sein)

Jcomod-IPC an/aus        -Dde.cib.jcomod.useIpc=true (optional, Default = false)

Hinweis zu JComod-IPC:

Wird JComod-IPC zusammen mit Webstart auf einem Windows Vista System ausgeführt, muss darauf geachtet werden, dass alle für die Applikation notwendigen Dateien in einem Verzeichnis gespeichert werden, welches kein Integrity gesetzt hat. Hintergrund ist der unter Windows Vista verwendete Integrity Mechanismus zur Einschränkung der Rechte für Applikationen.

Benutzereinstellungen speichern und laden

Im JView besteht die Möglichkeit, verschiedene benutzerspezifische Einstellungen nach dem Beenden zu speichern und sie nach dem erneuten Start des JView wieder herzustellen.

Durch die Property ICibApplication.PROPERTY_USER_PREFERENCES_FILE wird der Name der Datei angegeben, in der die Benutzereinstellungen gespeichert werden sollen. Das Setzen dieser Property ist Voraussetzung, dass überhaupt Benutzereinstellungen gespeichert werden.

Die untenstehende Tabelle zeigt, welche Benutzereinstellungen gespeichert werden können. Darüber hinaus kann durch weitere Properties festgelegt werden, ob einzelne Einstellungen gespeichert werden oder nicht.

Im Folgenden werden drei Code-Beispiele gezeigt, wie die Benutzereinstellungen gespeichert und wieder geladen werden können.

Methode die beim Beenden des Viewers die Einstellungen speichert, sie muss im Exit-Hook des Viewers aufgerufen werden:

       public
static void closeViewer(JCibView viewer) {
             if (viewer == null)
                    return;
 
             // store last frame position and size
             UserPreferences userPrefs = viewer.getUserPreferences();
             Boolean saveFramePos = (Boolean) viewer.getProperty(
              ICibApplication.PROPERTY_RESTORE_WINDOW_BOUNDS_ENABLED);
             if (userPrefs != null && saveFramePos != null &&
                           saveFramePos.booleanValue()) 
              userPrefs.saveWindowBounds(viewer.getFrame());
             
             // store toolbar location
             if (userPrefs != null) {
                    String loc = viewer.getUI().getToolbarPosition();
                    if (loc != null)
                        userPrefs.saveToolbarLocation(loc);
             }
             
             // store tab pane status
             if (userPrefs != null) {
                    boolean isOpen = viewer.getUI().isToolPanelVisible();
                userPrefs.saveTabPaneStatus(isOpen);
             }
 
             // store selected tab
             if (userPrefs != null) {
                    String selectedTab = viewer.getUI().getSelectedTab();
              userPrefs.saveSelectedTab(selectedTab);
             }
 
             // close magnifier – stores implicitely last magnifier position
             JCibDocumentPane pane = (JCibDocumentPane) viewer
                           .getOutputComponent();
             if (pane != null) {
                    if (pane.getMagnifierController() != null &&
                            pane.getMagnifierController().isActive())
                     pane.getMagnifierController().deactivate();
             }
             viewer.stop();
       }

Variablen und Methode zum Laden der bisherigen Einstellungen beim Starten des Viewers:

       // definition of constants and variables
       /** line separator */
       public static final String SEPARATOR = System.getProperty("file.separator");
       
       /** the user home directory */
       public static String user_home = System.getProperty("user.home");
 
       /** the cib specific user directory for ini and property files */
       public static String cib_user_dir;
 
       /** the user specific property file */
       public static String cib_user_file;
 
       // init the user preferences files
       cib_user_dir = user_home+"Anwendungsdaten"+SEPARATOR+"cib"+SEPARATOR;
       File user_dir = new File(cib_user_dir);
       if (!user_dir.exists())
             user_dir.mkdir();
       cib_user_file = cib_user_dir+"CibJView.prefs";
 
       public static void initializeViewer(JCibView viewer) {
             // init user preferences and set the user preferences file
        viewer.setProperty(ICibApplication.PROPERTY_USER_PREFERENCES_FILE,
                    cib_user_file);
             viewer.setProperty(
              ICibApplication.PROPERTY_RESTORE_WINDOW_BOUNDS_ENABLED,
                    Boolean.TRUE);
             viewer.setProperty(
              ICibApplication.PROPERTY_MAGNIFIER_ENABLED,
                    Boolean.TRUE);
 
             // restore toolbar location
              UserPreferences userPrefs = viewer.getUserPreferences();
             int toolbarPos = SwingConstants.TOP; // default
             if (userPrefs != null) {
                    Integer newToolbarPos = userPrefs.getToolbarLocation();
                     if (newToolbarPos != null)
                           toolbarPos = newToolbarPos.intValue();
             }
        viewer.setProperty(ICibApplication.PROPERTY_TOOLBAR_POSITION,
                    new Integer(toolbarPos));
 
             // restore tab pane status
             if (userPrefs != null) {
                    String selectedTab = "";
                    Boolean isOpen = userPrefs.getIsTabpaneOpen();
                    if (isOpen == null || isOpen) {
                           isOpen = Boolean.TRUE;
                           selectedTab = userPrefs.getSelectedTabOnStart();
                    }
                    else
{
                           isOpen = Boolean.FALSE;
                    }
                    // restore selected tab - if empty no tab is opened
                    viewer.setProperty(
                            ICibApplication.PROPERTY_SHOW_TAB_ON_START,
                                  selectedTab);
             }
 
             // last magnifier position is implicitely restored when
             // magnifier is opened and user preferences are active
       }

Methode die beim Erzeugen des Viewer-Frames die bisherigen Einstellungen lädt:

       public static JFrame createViewerFrame(final JCibView viewer) {
             // get the user preferences to restore the main frame position
             UserPreferences userPrefs = viewer.getUserPreferences();
             Boolean restoreFramePosEnabled = (Boolean) viewer.getProperty(
              ICibApplication.PROPERTY_RESTORE_WINDOW_BOUNDS_ENABLED);
 
             // load last frame's position if configured
             Rectangle t_framePos = null;
             if (userPrefs != null && restoreFramePosEnabled != null &&
                     restoreFramePosEnabled.booleanValue()) 
                    t_framePos = userPrefs.getFrameBounds();
             if (t_framePos == null) {
                    // Set position/size to 0,0 and 75% of screen width/height.
                    Dimension screenSize = Toolkit.getDefaultToolkit()
                           .getScreenSize();                
                    t_framePos = new Rectangle(0, 0, 
                           (int) (screenSize.getWidth() * 0.75), 
                           (int) (screenSize.getHeight() * 0.75));
             }
              // We need a frame to put the Viewer inside.
             GraphicsConfiguration gc = GraphicsUtilities
              .getGraphicsConfiguration(t_framePos);
             // create the frame on screen according to the frame's last position
             final JFrame t_frame = new JFrame(gc);
             // restore the frame's last position
             t_frame.setLocation(t_framePos.x, t_framePos.y);
             t_frame.setSize(t_framePos.width, t_framePos.height);
             viewer.setFrame(t_frame);
             return t_frame;
}

1. Erzeugen einer Instanz von jCibView -> cibJView = new JCibView();
2. initializeViewer(cibJView);
3. createViewerFrame(cibJView);
4. cibJView.start();
5. cibJView.load();

Code-Beispiel:

import javax.swing.JFrame;
import de.cib.gui.framework.ICibApplication;
import de.cib.view.*;
import com.cib.comod.jobs.*;
 
public class JViewTest {
      public static void main(java.lang.String[] args) {
            JCibView cibJView = new JCibView();
       cibJView.setProperty(ICibApplication.PROPERTY_INPUTFILE, "test.pdf");
            initializeViewer(cibJView);
            JFrame myFrame = createViewerFrame(cibJView);
            myFrame.setTitle("JView Test");
 
            cibJView.start();
            cibJView.load();
 
       myFrame.getContentPane().add(cibJView);
            myFrame.setVisible(true);
      }
}

Einbindung des CIB jView in Java

In den unteren Abschnitten finden Sie kurze Codebeispiele für den Aufruf von CIB jView. Vergewissern Sie sich, dass die CIB office module sich im Library Path der Java Virtual Machine (JVM) und die benötigten JAR-Dateien in einem Classpath-Verzeichnis befinden.

Einbindung in eine HTML-Seite

HTML-Seite mit einem integrierten jView-Applet

<html>
      <head>
            <title>CIB JView</title>
      </head>
      <body>
            <applet archive="CibJView.jar,
ComodJobs.jar"
             code="de/cib/view/JCibViewApplet.class"
                  width="100%"
height="100%" ID="Applet1">
            </applet>
      </body>
</html>

Einbindung in eine Java Swing-Applikation

import
javax.swing.JFrame;
import
de.cib.gui.framework.ICibApplication;
import
de.cib.view.*;
import
com.cib.comod.jobs.*;
 
public
class JViewFrame {
      public static void main(java.lang.String[] args) {
            JFrame myFrame = new JFrame();
            myFrame.setTitle("Test Frame");
            myFrame.setSize(800, 800);
            JCibView t_CIBView = new JCibView();
            t_CIBView.setFrame(myFrame);
       t_CIBView.setProperty(ICibApplication.PROPERTY_INPUTFILE,
                  "test.pdf");
            // keine Menüleiste anzeigen
       t_CIBView.setProperty(ICibApplication.PROPERTY_MENU_ENABLED,
                  new Boolean(false));
       t_CIBView.setProperty(ICibApplication.PROPERTY_EXPORT_ENABLED,
                  new Boolean(false));
            // keine JView Ini-Datei schreiben
       t_CIBView.setProperty(ICibApplication.PROPERTY_INIFILENAME,
                  null);
       t_CIBView.setProperty(ICibApplication.PROPERTY_TITLE,
                  new String("JCibView!"));
            t_CIBView.start();
            t_CIBView.load();
       myFrame.getContentPane().add(t_CIBView);
            myFrame.setVisible(true);
      }
}

import javax.swing.JDialog;
import de.cib.gui.framework.ICibApplication;
import
de.cib.view.*;
import
com.cib.comod.jobs.*;
 
public
class JViewDialog {
      public static void main(java.lang.String[] args) {
            JDialog myDialog = new JDialog ();
            myDialog.setTitle("Test Dialog");
            myDialog.setSize(800, 800);
            JCibView t_CIBView = new JCibView();
            t_CIBView.setFrame(myDialog);
            t_CIBView.setProperty(ICibApplication.PROPERTY_INPUTFILE,
                  "example.tif");
            // keine Menüleiste anzeigen
       t_CIBView.setProperty(ICibApplication.PROPERTY_MENU_ENABLED,
                  new Boolean(false));
       t_CIBView.setProperty(ICibApplication.PROPERTY_EXPORT_ENABLED,
                  new Boolean(false));
            // keine JView Ini-Datei schreiben
       t_CIBView.setProperty(ICibApplication.PROPERTY_INIFILENAME,
                  null);
       t_CIBView.setProperty(ICibApplication.PROPERTY_TITLE,
                  new String("JCibView!"));
            t_CIBView.start();
            t_CIBView.load();
       myDialog.getContentPane().add(t_CIBView);
            myDialog.setVisible(true);
      }
}

Nachfolgendes Codebeispiel zeigt die Möglichkeit, einen selbstprogrammierten Druckdialog in den JView einzuhängen.

Wichtige Hinweise:

Wenn Sie die Klasse JCibPrinterJob erweitern, dann überschreiben Sie bitte die Methode print() nicht, oder wenn dies unvermeidlich ist, stellen Sie sicher, dass Sie die Methode super() aufrufen, sonst kann das Drucken nicht erwartungsgemäß erfolgen.

JCibView geht standardmäßig davon aus, dass die aktuelle Seite gedruckt werden soll. Er setzt intern die CIB Format Property ICibFormatJob.PROPERTY_CURRENTPAGE auf die aktuelle Seitenzahl. Um ein unerwünschtes Drucken nur der aktuellen Seite zu vermeiden, setzen Sie die Property PROPERTY_CURRENTPAGE auf -1.

import javax.swing.JFrame;
import de.cib.view.*;
import com.cib.comod.jobs.*;
import com.cib.comod.tools.print.*;
import java.awt.*;
 
public class JViewFrame {
 
      public static void main(java.lang.String[] args) {
            JFrame myFrame = new JFrame();
            myFrame.setTitle("Test Frame");
            myFrame.setSize(300,300);
            JCibView t_CIBView = new JCibView (myFrame);
 
            // Mein eigener PrinterJob soll benutzt werden
       System.setProperty("com.cib.tools.print.printerjob",
                  "my.package.MyPrinterJob");
       t_CIBView.setProperty(ICibApplication.PROPERTY_INPUTFILE,
                  "test.rtf");
       t_CIBView.setProperty(ICibApplication.PROPERTY_SEARCH_ENABLED,
                  new Boolean(false));
            // keine Menüleiste anzeigen
       t_CIBView.setProperty(ICibApplication.PROPERTY_MENU_ENABLED,
                  new Boolean(false));
       t_CIBView.setProperty(ICibApplication.PROPERTY_EXPORT_ENABLED,
                  new Boolean(false));
       t_CIBView.setProperty(ICibApplication.PROPERTY_TITLE,
                  new String("JCibView!"));
 
            t_CIBView.start();
            t_CIBView.load();
 
       myFrame.getContentPane().add(t_CIBView);
            myFrame.setVisible(true);
      }
}
 
package my.package;
import com.cib.comod.tools.print.*;
 
public class MyPrinterJob extends JCibPrinterJob {
      // Die Methode gibt true zurück, wenn gedruckt werden soll,
      // andernfalls false.
      public boolean printDialog()
      {
            // HHHHHHhhier fügen Sie Ihren Dialog-Code ein.
            .......
      }
}

import java.awt.BorderLayout;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
import de.cib.gui.framework.ICibApplication;
import de.cib.gui.framework.JCibApplication;
import de.cib.jRec.ICibRecApplication;
import de.cib.util.trace.Trace;
 
public class JCibViewTest {
 
      public static final String TEST_FILENAME = "test_rec.rtf";
 
      public static void main(java.lang.String[] args) {
            // We need a frame to put the Viewer inside.
            JFrame t_frame = new JFrame();
            
            // We need a viewer.
            final JCibView t_CIBView = new JCibView();
            t_CIBView.setFrame(t_frame);
            
            // Prepare frame.
        t_frame.setDefaultCloseOperation(
                   WindowConstants.DO_NOTHING_ON_CLOSE);
            
            try {
                  t_frame.addWindowListener(new WindowAdapter() {
                        public void windowClosing(WindowEvent e) {
                              //call stop for clean ups!
                              t_CIBView.stop();
                        }
                  });
            }
            catch (Throwable exception) {
                Trace.trace("Prepare frame " , exception);
            }
            t_frame.setSize(
             (int)(Toolkit.getDefaultToolkit().getScreenSize()
                        .getWidth()) * 0.75),
                  (int) ((Toolkit.getDefaultToolkit()
                        .getScreenSize().getHeight()) * 0.75));
       t_frame.getContentPane().setLayout(new BorderLayout());
            
            // Prepare viewer.
            // Set input file (optional)
       t_CIBView.setProperty(ICibApplication.PROPERTY_INPUTFILE,
                              TEST_FILENAME);
            // Enable JCibRec in JCibView (optional).
       t_CIBView.setProperty(ICibRecApplication.PROPERTY_REC_ENABLED,
                  Boolean.TRUE);
            JCibApplication t_cibRec = t_CIBView.getRec();
            
            // Set constraints to allowed font list (optional).
            if (t_cibRec != null) {
                  String fontList = "Times New Roman; Arial; Courier New";
                t_CIBView.getRec().setProperty(
                   ICibRecApplication.PROPERTY_ALLOWED_FONT_LIST, 
                        fontList);
            }
            // Use native print dialog (optional).
            // Otherwise the Java print dialog is used.
            t_CIBView.setProperty(
                   ICibApplication.PROPERTY_SHOWJPRINTDIALOG, 
                        Boolean.FALSE);
            
            t_CIBView.start();            
            t_CIBView.load();
            
       t_frame.getContentPane().add(t_CIBView, BorderLayout.CENTER);
            t_frame.setVisible(true);
    }
}

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
 
import com.cib.comod.jobs.ICibMergeJob;
import com.cib.comod.jobs.JCibMergeJob;
 
import de.cib.gui.framework.CibMessageDialog;
import de.cib.gui.util.trace.Trace;
import de.cib.metafile.Messages;
import de.cib.view.modules.jRec.jRecController;
import de.cib.webdesk.utilities.IOUtilities;
 
public class JMergeTestRunner {
 
      /**
       * Mischt zwei RTF-Snippets mit CIB merge in Input-RTF-Datei ein.
       * Das Ergebnis wird in die angegebene Output-Datei gespeichert. 
       */
      public static void main(java.lang.String[] args) {
 
            // Set file path to example files - must be adjusted
            String path = "C:/Testfiles/";
            
            // Create RTF document by CIB merge job with merge/recombine.
            File inputFile = new File (path + "merge-Test-In.rtf");
            File outputFile = new File (path + "merge-Test-Out.rtf");
            
            String snippet0 = new String (path + "jRec_snippet_0");
            String snippet1 = new String (path + "jRec_snippet_1");
            
            HashMap<Integer, String> rtfControls = 
                        new HashMap<Integer, String>();
            rtfControls.put(new Integer(0), 
                        new String(IOUtilities.readFile(snippet0)));
            rtfControls.put(new Integer(1), 
                        new String(IOUtilities.readFile(snippet1)));
                        
            try {
                  // Merge-Job initialisieren
                  JCibMergeJob t_mergeJob =  new JCibMergeJob();
                  t_mergeJob.initialize();
                  
                  if (t_mergeJob != null && t_mergeJob.isInitialized()) {
                        File snippetDir = new File(
                           jRecController.getSnippetDir());
                        // Merge Error log in Snippet-Verzeichnis speichern
                        File logFile = null;
                        if (snippetDir.exists()) {
                              logFile = new File(jRecController.getSnippetDir()
                                     + "merge_recombine.log");
                              if (logFile.exists())
                                    logFile.delete();
                              t_mergeJob.setProperty(
                                 ICibMergeJob.PROPERTY_ERRORFILE, 
                                    logFile.getAbsolutePath());
                              t_mergeJob.setProperty(
                                   ICibMergeJob.PROPERTY_VERBOSE,
                                    "5+all+source");
                        }
                        t_mergeJob.setProperty(
                           ICibMergeJob.PROPERTY_INPUTFILE, 
                              inputFile.getAbsolutePath());
                        if (outputFile.exists())
                              outputFile.delete();
                        t_mergeJob.setProperty(
                          ICibMergeJob.PROPERTY_OUTPUTFILE, 
                             outputFile.getAbsolutePath());
                        t_mergeJob.setProperty(
                         ICibMergeJob.PROPERTY_EXTENDEDREF, 
                              Boolean.TRUE);
                        t_mergeJob.setProperty(
                          ICibMergeJob.PROPERTY_CHARFORMAT, "auto");
                        t_mergeJob.setProperty(
                              ICibMergeJob.PROPERTY_KEEP, "unresolved-ref");
                        // Neuer Parameter, um vorhandene Field-Results 
                        // bei nicht vorhandener Datenversorgung zu erhalten.
                        t_mergeJob.setProperty(

                              "--field-results=", "keepswitch");
                              "--field-results=", "keepswitch");
                        // RTF Snippets, die den Inhalt im RTF ersetzen. 
                        // Können auch von Platte kommen.
                        if (rtfControls != null) {
                              Integer fieldID;
                              String snippetName; 
                              Iterator<Integer> it = 
                                 rtfControls.keySet().iterator();
                              while (it.hasNext()) {
                                    fieldID = it.next();
                                    String rtfPassage = 
                                          rtfControls.get(fieldID);
                                    if (rtfPassage != null) {
                                          // Set property value for rtf snippet
                                          snippetName = "cibrec-snippet" 
                                                + fieldID.intValue() + ".rtf=";
                                          t_mergeJob.setProperty(
                                                "--directory-set=", 
                                                snippetName + rtfPassage);
                                    }
                              }
                        }
                        
                        // Merge-Job ausführen
                        t_mergeJob.execute();
                        
                        // Fehlerbehandlung
                        int t_Error = ((Integer)t_mergeJob.getProperty(

                               ICibMergeJob.PROPERTY_ERROR)).intValue();
                               ICibMergeJob.PROPERTY_ERROR)).intValue();
                        if (t_Error != 0) {
                              // Fehler beim Ausführen des Merge-Jobs
                              String t_Errortext = 

                                  (String)t_mergeJob.getProperty(

                                      ICibMergeJob.PROPERTY_ERRORTEXT);
                                  (String)t_mergeJob.getProperty(
                                      ICibMergeJob.PROPERTY_ERRORTEXT);
                              Trace.traceln("Error executing merge job: "
                                    + t_Error + " " + t_Errortext);
                        }
                  }
            } catch (Exception e) {
                // Fehlerbehandlung
                  Trace.traceln("Save RTF + fields with CIB merge failed.\n"
                        + "Please check the installation of cibmrg32.dll.");
                  e.printStackTrace();
            }
    }
}

Die Datenstruktur CustomCloseDialogInfo dient zum Austausch von Informationen für den CustomCloseDialogCallback, sie ist im CIB jView (package de.cib.view.modules) definiert. 

Interface CustomCloseDialogInfo:

package
de.cib.view.modules;
 
/**
 * Interface describing the data structure for custom close dialog
 * with information to form and sign fields.
 * 
 */
public interface CustomCloseDialogInfo {
 
      /**
       * Returns whether the form is changed or not
       * @return boolean flag
       */
      boolean isFormChanged();
      
      /**
       * Gets the unsigned mandatory field count
       * @return number of unsigned mandatory fields
       */
      int getUnsignedMandatorySignatureCount();
      
      /**
       * Gets the unsigned optional field count
       * @return number of unsigned optional fields
       */
      int getUnsignedOptionalSignatureCount();
}

Das Interface CustomCloseDialogCallback ist im CIB jView (package de.cib.view.modules) definiert und umfasst folgende Methoden.

Interface CustomCloseDialogCallback:

package
de.cib.view.modules;
 
/**
 * Interface defining the callback for custom close dialog
 * 
 */
public interface CustomCloseDialogCallback {
            
      /**
       * Method showCustomCloseDialog
       * @param customCloseDialogInfo interface to read form&sign data
       * @return returnCode of CustomCloseDialog
       *  0 - Yes
       *  1 - No
       *  2 - Cancel
       */
      public int showCustomCloseDialog(
CustomCloseDialogInfo customCloseDialogInfo);
 
}

Der Aufrufer muss sich dazu bei der JView-Instanz als Listener anmelden, dazu ein Code-Beispiel:

//
register CustomCloseDialogCallback
viewer.setCustomCloseDialogCallback(new CustomCloseDialogCallback() {
      @Override
      public int showCustomCloseDialog(
CustomCloseDialogInfo customCloseDialog) {
            int unsignedMandatoryCount = customCloseDialog
             .getUnsignedMandatorySignatureCount();
            int unsignedOptionalCount = customCloseDialog
  .getUnsignedOptionalSignatureCount();
            int unsignedSignatureCount = unsignedMandatoryCount 
                  + unsignedOptionalCount;
            String message = "";
            if (customCloseDialog.isFormChanged())
                  message = "Das Dokument enthält Änderungen an Formularfeldern, die noch nicht gespeichert wurden.";
 
            if (unsignedSignatureCount > 0) {
                  if (!message.isEmpty())
                        message += "\n";
                  message += "Das Dokument enthält noch %1 zu signierende(s) Feld(er), %2 Pflicht-
und %3 optionale Feld(er).";
                  message = message.replaceFirst("%1", 

                   String.valueOf(unsignedSignatureCount));
                   String.valueOf(unsignedSignatureCount));
                  message = message.replaceFirst("%2", 
                   String.valueOf(unsignedMandatoryCount));
                  message = message.replaceFirst("%3",
                   String.valueOf(unsignedOptionalCount));
            }
            if (message.isEmpty())
                  return JCibOptionPane.YES_OPTION;
 
            message += "\nMöchten Sie die Bearbeitung trotzdem beenden?";
            return JCibOptionPane.showYesNoDialog(
                  viewer, message,"Rückfrage"));
      }
});

Methode zur Abfrage des Rückgabewerts beim Beenden-Dialog:

In der Viewer-Instanz (Klasse JCibView) ist die Methode getCloseAction() verfügbar, die den Rückgabewert des Beenden-Dialogs liefert.

int closeDialogButton = viewer.getCloseAction();

Mögliche Werte (siehe auch CustomCloseDialogCallback):

 0 – Ja
 1 – Nein
 2 – Abbrechen
-1 – Vorbelegung (Dialog wurde nicht geöffnet)

Code-Beispiel für die Abfrage des gedrückten Buttons nach dem Beenden im Exit-Hook:

viewer.setExitHook(new Runnable() {
      public void run() {
            // do post processing here
            viewer.stop();
            // unregister FormFieldCallback Listener
            viewer.setFormFieldCallback(null);
            // Unregister SignFieldCallback Listener
            viewer.setSignFieldCallback(null);
 
            int closeDialogButton = viewer.getCloseAction();
            System.out.println("The following button was pressed in the close dialog: " + closeDialogButton);
      }
});

Einbindung in eine Java SWT-Applikation

Um JCibView in eine SWT-Applikation zu integrieren, müssen einige Besonderheiten beachtet werden. JCibView muss in einen AWT-Frame eingebettet werden, der als oberstes Objekt eine Instanz von RootPaneContainer (z.B. JApplet) enthält. In diesen RootPaneContainer werden dann alle weiteren Komponenten eingefügt.

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Frame;
 
import javax.swing.JApplet;
import javax.swing.SwingUtilities;
 
import org.eclipse.swt.SWT;
import org.eclipse.swt.awt.SWT_AWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
 
import de.cib.gui.framework.ICibApplication;
import de.cib.view.JCibView;
 
public class JViewInSWT {
 
      public static final String TEST_FILENAME = "c://tmp//testdoc.rtf";
 
      public static void main(String[] args)
      {
            final Display display = new Display();
            final Shell shell = new Shell(display);
            shell.setLayout(new FillLayout());
            shell.setText("Shell for JView integriert in SWT");
            Composite composite = new Composite(shell, SWT.NO_BACKGROUND
                  | SWT.EMBEDDED);
            
            /*
             * Set a Windows specific AWT property that prevents 
             * heavyweight components from erasing their background. 
             * Note that this is a global property and cannot be scoped. 
             * It might not be suitable for your application.
             */
            try {
               
System.setProperty("sun.awt.noerasebackground", "true");
            }
            catch (NoSuchMethodError error) {
            }
            
            /* Create and set up frame */
            // Use an embedded frame for SWT/AWT integration
            Frame frame = SWT_AWT.new_Frame(composite);
            final JCibView viewer = new JCibView(frame);
            
            // SWT/AWT needs a RootPaneContainer as intermediate object,
            // for example a JApplet object.
            JApplet applet = new JApplet();
            frame.add(applet);
            
            // Get content pane from the applet
            Container contentPane = applet.getContentPane();
            contentPane.setLayout(new BorderLayout());
            contentPane.add(viewer.getJMenuBar(), BorderLayout.NORTH);
            contentPane.add(viewer, BorderLayout.CENTER);
            contentPane.setVisible(true);
            
            frame.pack();
            frame.setVisible(true);
 
            viewer.setVisible(true);
 
            // Set input file (optional)
            viewer.setProperty(ICibApplication.PROPERTY_INPUTFILE,
                              TEST_FILENAME);
            viewer.setProperty(ICibApplication.PROPERTY_TITLE,
                  "CIB JView integriert in SWT");
            
            viewer.start();
            viewer.load();
            
            shell.open();
            
            // Grab focus after shell open using invokeLater
           SwingUtilities.invokeLater(new Runnable()
            {
                  public void run()
                  {
                        viewer.grabFocus();
                  }
            });
            
            while (!shell.isDisposed()) {
                  if (!display.readAndDispatch())
                        display.sleep();
            }
            
            display.dispose();
      }
}