Универсальный бандл templ-universal

import org.jabricks.universal.JBPanel;
import org.jabricks.universal.ComponentParams;
import org.jabricks.widgets.constants.IWidgetsConstants;

@SuppressWarnings("serial")
public class JPanelForm extends JBPanel 
                        implements IWidgetsConstants
{
    private  TemplActivator  activator = null;
    private  CommonGUI       gui       = null;
    //-----------------------------------------------------
    public JPanelForm(TemplActivator activator, 
                      Container      container)
    {
        super(activator.getBundleContext());
        this.activator = activator;

        createPanel(container);
    }
    //-----------------------------------------------------
    @Override
    protected void createPanel(Container container)
    {
        // Создание интерфейсного класса
        gui = new CommonGUI(context, this, GUIMode_jpanel);
        // Чтение сохраненных настроек
        gui.readComponentParams();
        gui.setActivator(activator);
        // Создание интефейсной панели
        gui.createDesk();
        // Размещение интефейсной панели в контейнере
        container.add(gui.getPnlDesk());
        gui.getPnlDesk().setVisible(false);
        // Создание интерфейса
        gui.createGUI(gui.getPnlDesk());

        // Контейнер размещения интерфейса дочернего бандла
        JPanel pnl = (JPanel) gui.getContainer4Bundle();

        if (pnl != null)
            createStartTimeLabel(pnl);

        container.doLayout();
        gui.getPnlDesk().doLayout();
        gui.getPnlDesk().setVisible(true);
    }
    //-----------------------------------------------------
    private void createStartTimeLabel(JPanel pnl)
    {
        SimpleDateFormat sdf;
        sdf = new  SimpleDateFormat("dd.MM.yyyy hh:mm:ss"); 
        JLabel lbl = new JLabel();
        String active     = "ACTIVE";
        Date dt = new Date(activator.getStartTime());
        String start_time = sdf.format(dt);

        // Время сохранения
        String save_time  = "null";
        if (getSaveDateTime() != null) {
            long offs = activator.getStartTime() - 
                        getSaveDateTime().getTime();
            if (offs > 0)
                active = "NOT ACTIVE";
            save_time = sdf.format(getSaveDateTime());
        }

        lbl.setText(start_time + "  :  " + active + 
                     "  ( " + save_time + " )");
        lbl.setForeground(Color.ORANGE);

        pnl.setLayout(new BorderLayout());
        pnl.add(lbl, BorderLayout.SOUTH);
        pnl.doLayout();
    }
    //-----------------------------------------------------
    public Container getContainer4Bundle()
    {
        return gui.getContainer4Bundle();
    }
    //-----------------------------------------------------
    @Override
    public void saveComponentParams() 
    {
        if (gui != null)
            ((CommonGUI)gui).saveComponentParams();
    }
    //-----------------------------------------------------
    @Override
    public JPanel getJPanel()
    {
        return ((CommonGUI)gui).getPnlDesk();
    }
    //-----------------------------------------------------
}
 

import java.awt.Container;
import java.awt.Dimension;
import java.awt.BorderLayout;

import org.jabricks.resources.IResources;
import org.jabricks.resources.ResourcesImpl;
import org.jabricks.universal.ComponentParams;
import org.jabricks.widgets.constants.IWidgetsConstants;

import org.jabricks.universal.JBDialog;

public class JDialogForm extends JBDialog 
                         implements IWidgetsConstants
{
    private  int        DEFAULT_WIDTH  = 600;
    private  int        DEFAULT_HEIGHT = 400;

    private  CommonGUI  gui = null;
    //-----------------------------------------------------
    public JDialogForm(TemplActivator activator)
    {
        super(activator.getBundleContext());

        // Определение иконки
        IResources rsc = new ResourcesImpl();
        if (rsc != null)
            getJDialog().setIconImage(rsc.getAppIcon());

        // Создание интерфейса
        getJDialog().setVisible(false);

        gui = new CommonGUI(context, this, GUIMode_jdialog);
        gui.readComponentParams();
        gui.setActivator(activator);
        gui.createDesk();

        // Получение панели содержимого
        Container container = getJDialog().getContentPane();

        // Размещение панели desk
        container.add(gui.getPnlDesk(),BorderLayout.CENTER);
        gui.createGUI(gui.getPnlDesk());

        // Расположение поверх остальных
        getJDialog().setAlwaysOnTop(true);

        if (gui.form_dim != null) {
            getJDialog().setSize(gui.form_dim);
            DEFAULT_WIDTH  = gui.form_dim.width;
            DEFAULT_HEIGHT = gui.form_dim.height;
        }
        Dimension dim;
        dim = Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        getJDialog().setPreferredSize(dim);
        // Центрирование формы
        formCentering(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        getJDialog().setVisible(true);
    }
    //-----------------------------------------------------
    @Override
    public void saveComponentParams() 
    {
        if (gui != null)
            ((CommonGUI)gui).saveComponentParams();
    }
    //-----------------------------------------------------
    public Container getContainer4Bundle()
    {
        return gui.getContainer4Bundle();
    }
}
 

public class CommonGUI extends JBCommon
                       implements IWidgetsConstants 
{
    private  TemplActivator activator = null;
    private  Object         parent    = null;
    private  BundleContext  context   = null;
    private  JSplitPane     split     = null;
    private  final  int     DIVIDER   = 300;

    private  final  String  SPLITPANE = "SPLITPANE";
    private  final  String  RESOURCES = "properties/props";

    private  JPanel         pnlLeft   = null;
    private  JButton        btnStart  = null;
    private  JButton        btnClose  = null;

    private  String         version   = null;
    private  String         guimode   = null;
    //-----------------------------------------------------
    public CommonGUI (final BundleContext context, 
                      final Object parent,
                      final String guimode)
    {
        this.parent  = parent;
        this.guimode = guimode;
        this.context = context;

        IResources rsc = new ResourcesImpl();
        // Текущая locale
        this.locale = rsc.getLocale();

        version = getBundle().getVersion().toString();
    }
    //-----------------------------------------------------
    private Bundle getBundle()
    {
        return context.getBundle();
    }
    //-----------------------------------------------------
    public void setActivator(TemplActivator activator)
    {
        this.activator = activator;
    }
    //-----------------------------------------------------
    private void createSplitPane() 
    {
        split = new JSplitPane();
        split.setName(SPLITPANE);
        
        // JSplitPane.HORIZONTAL_SPLIT, 
        split.setOneTouchExpandable(false);
        split.setOrientation(JSplitPane.HORIZONTAL_SPLIT);

        if ((cparams == null) || (cparams.size() == 0))
            split.setDividerLocation(DIVIDER);
        else {
            ComponentParams cp  = null;
            String          cls = null;
            cls = JSplitPane.class.getSimpleName();
            cp  = extractComponentParams(cls, SPLITPANE);
            if (cp != null)
                split.setDividerLocation(cp.getLocation());
            else
                split.setDividerLocation(DIVIDER);
        }
        pnlLeft         = new JPanel();
        JPanel pnlRight = new JPanel();

        pnlLeft .setLayout(new BorderLayout());
        pnlRight.setLayout(new BorderLayout());

        if (version.startsWith("1.0")) {
            pnlLeft .setBackground(Color.red   );
            pnlRight.setBackground(Color.yellow);
        } else {
            pnlLeft .setBackground(Color.blue  );
            pnlRight.setBackground(Color.green );
        }

        split.setLeftComponent (pnlLeft );
        split.setRightComponent(pnlRight);

        Bundle bndl = getBundle();
        String gav = bndl.getSymbolicName() + ";" +
                     bndl.getVersion().toString();
        JLabel lblGAV = new JLabel(gav);
        lblGAV.setSize(120, 24);

        btnStart = new JButton("Start bundle");

        Border border;
        border = BorderFactory.createEmptyBorder(5,5,5,5);
        pnlRight.setBorder (border);

        pnlRight.setLayout(new BorderLayout());
        pnlRight.add(lblGAV, BorderLayout.NORTH);
        pnlRight.add(btnStart, BorderLayout.SOUTH);

        btnStart.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                activator.startChildBundle();
            }
        });
    }
    //-----------------------------------------------------
    private String getGAV(Bundle bndl)
    {
        String gav = bndl.getSymbolicName() + "-" +
                     bndl.getVersion().toString();
        return gav;
    }
    //-----------------------------------------------------
    private void createChildGUI(JPanel panel)
    {
        String gav = getGAV(getBundle());
        if (!guimode.equalsIgnoreCase(GUIMode_jdialog)) {
            panel.setBackground(Color.CYAN);
            JLabel lblGAV = new JLabel(gav);
            panel.add(lblGAV, BorderLayout.NORTH);
        } else {
            ((JDialogForm)parent).setTitle(gav);
            JPanel pnlButtons = createButtonsPanel();
            panel.add(pnlButtons, BorderLayout.SOUTH);
        }
    }
    //-----------------------------------------------------
    public void createGUI (JPanel panel)
    {
        panel.setVisible(false);

        panel.setLayout(new BorderLayout());

        if (version.equalsIgnoreCase("1.0.0") || 
            version.equalsIgnoreCase("2.0.0")) {
            createSplitPane(cparams);
            panel.add(split, BorderLayout.CENTER);
        } else {
            createChildGUI(panel);
        }
        IResources resources = new ResourcesImpl();
        Locale locale = resources.getLocale();
        changeLocale (locale);

        panel.doLayout();
        panel.setVisible(true);
    }
    //-----------------------------------------------------
    public Container getContainer4Bundle()
    {
        return pnlLeft;
    }
    //-----------------------------------------------------
    /**
     * Создание панели кнопок управления
     * @return панели управления JPanel
     */
    private JPanel createButtonsPanel()
    {
        btnClose = new JButton(SPAN_normal + "Close");
        btnClose.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    ((JDialogForm)parent).setVisible(false);
                    ((JDialogForm)parent).dispose();
                    Bundle bndl = getBundle(); 
                    bndl.stop();
                } catch (BundleException ex) {}
            }
        });

        // Создание панели с табличным расположением
        JPanel ctrl = new JPanel(new GridLayout(1,2,5,0));
        ctrl.add (btnClose);

        JPanel flow;
        flow = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        flow.add(ctrl);
        return flow;
    }
    //-----------------------------------------------------
    public void changeLocale (Locale locale)
    {
        ResourceBundle  rsc; 
        rsc = ResourceBundle.getBundle (RESOURCES, locale);

        String start = "btn.ok";
        String close = "btn.close";
        String title = RESOURCE_title;

        if (rsc != null) {
            title = rsc.getString(RESOURCE_title) + " ( " +
                    getGAV(getBundle()) + " )";
            start = SPAN_normal + rsc.getString(start);
            close = SPAN_normal + rsc.getString(close);
        }
        if (guimode.equalsIgnoreCase(GUIMode_jdialog)) {
            ((JDialogForm)parent).setTitle(title);
            if (btnClose != null)
                btnClose.setText (close);
        }
        if (btnStart != null) {
            btnStart.setText (start);
        }
    }
    //-----------------------------------------------------
    @Override
    protected int getWidth()
    {
        if (guimode.equalsIgnoreCase(GUIMode_jdialog)) {
            JDialog jdialog = ((JDialogForm)parent).getJDialog(); 
            return jdialog.getWidth();
        } else
            return 0;
    }
    //-----------------------------------------------------
    @Override
    protected int getHeight()
    {
        if (guimode.equalsIgnoreCase(GUIMode_jdialog)) {
            JDialog jdialog = ((JDialogForm)parent).getJDialog(); 
            return jdialog.getHeight();
        } else
            return 0;
    }
    //-----------------------------------------------------
}
 

@Override
public void start(final BundleContext context) 
                               throws Exception {
    super.start(context);

    // Подключение слушателей ("подписка")
    createStartTimeResponseSubscriber(this);
    createLocaleSubscriber ();

    // Отправка запроса времени старта приложения
    sendStartTimeRequestEvent();
    // Определение режима представления
    getGuiMode();
}
//---------------------------------------------------------
@Override
public void changeLocale (Locale locale) 
{
    if (jdialog != null)
        ((JDialogForm)jdialog).changeLocale(locale);
    else if (jpanel != null)
        ((JPanelForm)jpanel).changeLocale(locale);
}
//---------------------------------------------------------
@Override
public void getStartTimeResponseMessage(long start_time)
{
    super.getStartTimeResponseMessage(start_time);
}
 

private Bundle getChildBundle()
{
    Bundle child    = null;
    String child_v  = null;

    // GAV параметры бандла
    Bundle bnd = context.getBundle();
    String sn  = bnd.getSymbolicName();
    String ver = bnd.getVersion().toString();

    // Версия дочернего бандла
    for (int i = 0; i < bundles.length; i++) {
        if (bundles[i][0].equals(ver)) {
            child_v = bundles[i][2];
            break;
        }
    }
    // Определение дочернего бандла
    for (int i=0; i < context.getBundles().length; i++) {
        bnd = context.getBundles()[i];
        String bnd_sn;
        String bnd_ver;

        bnd_sn = bnd.getSymbolicName();
        bnd_ver = bnd.getVersion().toString();
        if (bnd_sn.equalsIgnoreCase(sn) &&
            bnd_ver.equals(child_v)) {
                child = bnd;
                break;
            }
    }
    return child;
}
//---------------------------------------------------------
public void startChildBundle()
{
    Bundle child = getChildBundle();
    if ((child != null) &&
        (child.getState() != Bundle.ACTIVE)) {
            createGuimodeRequestSubscriber();
            try {
                child.start();
            } catch (BundleException e) {}
    }
}
 

/**
 * Создание диалогового окна
 */
@Override
protected void createDialogGUI()
{
    jdialog = new JDialogForm(context);
    ((JDialogForm)jdialog).addWindowListener(
        new WindowAdapter() {
        public void windowClosing(WindowEvent we) {
            jdialog.setVisible(false);
            try {
                // Останов бандла
                context.getBundle().stop();
            } catch (Exception e) {}
        }
    });
}
//---------------------------------------------------------
/**
 * Поступление контейнера главного фрейма
 */
@Override
public void getJFrameResponseContainer (Container container)
{
    jpanel = new JPanelForm(this, container);
}
//---------------------------------------------------------
private String getChildGuimode()
{
    Bundle bnd = context.getBundle();
    String gui_mode  = null;

    String version = bnd.getVersion().toString();
    for (int i = 0; i < bundles.length; i++){
        if (bundles[i][0].equals(version)) {
            gui_mode = bundles[i][1];
            break;
        }
    }
    return gui_mode;
}
//---------------------------------------------------------
/**
 * Метод обработки запроса режима представления GUI
 * родительским бандлом
 */
@Override
public void getGuimodeRequestMessage()
{
    super.getGuimodeRequestMessage();

    String guimode = getChildGuimode();
    if (guimode.equalsIgnoreCase(GUIMode_jpanel))
        // Подписчик для запроса панели
        createPanelRequestSubscriber();

    // Отправка сообщения с guimode
    sendGuimodeResponseEvent (guimode);
}
//---------------------------------------------------------
/**
 * Метод обработки ответа режима представления GUI
 * дочерним бандлом
 */
@Override
public void getGuimodeResponseMessage(String guimode)
{
    super.getGuimodeResponseMessage(null);

    if (guimode.equalsIgnoreCase(GUIMode_jdialog))
        createDialogGUI();
    else
        // send request 
        sendPanelRequestEvent();
}
 

private Container getContainer()
{
    Container c = null;
    if (jdialog != null)
        c = ((JDialogForm)jdialog).getContainer4Bundle();
    else if (jpanel != null)
        c = ((JPanelForm)jpanel).getContainer4Bundle();
    return c;
}
//---------------------------------------------------------
@Override
public void getPanelRequestMessage()
{
    super.getPanelRequestMessage();

    Container container = getContainer();
    if (container != null)
        sendPanelResponseEvent(container);
}
//---------------------------------------------------------
private void clearContainer (JPanel panel)
{
    for (int i = panel.getComponentCount()-1; i >= 0; i--)
        panel.remove(i);
}
//---------------------------------------------------------
@Override
public void getPanelResponseContainer(Container container)
{
    super.getPanelResponseContainer(null);

    if (container != null) {
        clearContainer ((JPanel) container);
        jpanel = new JPanelForm(this, container);
    }
}
 

@Override
public void stop(BundleContext context) throws Exception
{
    Bundle child = getChildBundle();
    if ((child != null) &&
        (child.getState() == Bundle.ACTIVE))
        child.stop();
    super.stop(context);
}
//---------------------------------------------------------
@Override
public void saveComponentParams() 
{
    if (jdialog != null)
        ((JDialogForm)jdialog).saveComponentParams();
    else if (jpanel != null)
        ((JPanelForm)jpanel).saveComponentParams();
}
 

<project xmlns="http://maven.apache.org/POM/4.0.0" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
             http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.jabricks.templates</groupId>
  <artifactId>templ-universal</artifactId>
  <packaging>bundle</packaging>
  <version>1.0.0</version>

  <name>JPanel template</name>
  <url>http://maven.apache.org</url>

  <properties>
      <project.build.sourceEncoding>
          UTF-8
      </project.build.sourceEncoding>
      <maven.test.skip>true</maven.test.skip>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  
  <dependencies>
      <dependency>
          <groupId>org.apache.felix</groupId>
          <artifactId>
              org.apache.felix.framework
          </artifactId>
          <version>5.6.1</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>org.apache.felix</groupId>
          <artifactId>
              org.apache.felix.eventadmin
          </artifactId>
          <version>1.2.2</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>org.jabricks.resources</groupId>
          <artifactId>util-resources</artifactId>
          <version>1.0.0</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>org.jabricks.widgets</groupId>
          <artifactId>gui-widgets</artifactId>
          <version>1.0.0</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>org.jabricks.universal</groupId>
          <artifactId>base-universal</artifactId>
          <version>1.0.1</version>
          <scope>provided</scope>
      </dependency>
  </dependencies>
  
  <build>
      <plugins>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>2.3.2</version>
              <configuration>
                  <source>${maven.compiler.source}</source>
                  <target>${maven.compiler.target}</target>
              </configuration>
          </plugin>
          <plugin>
              <groupId>org.apache.felix</groupId>
              <artifactId>maven-bundle-plugin</artifactId>
              <version>2.3.7</version>
              <extensions>true</extensions>
              <configuration>
                 <instructions>
                    <Bundle-SymbolicName>
                    ${project.groupId}.${project.artifactId}
                    </Bundle-SymbolicName>
                    <Bundle-Name>
                        ${project.name}
                    </Bundle-Name>
                    <Bundle-Version>
                        ${project.version}
                    </Bundle-Version>
                    <Bundle-Activator>
                        ${project.groupId}.TemplActivator
                    </Bundle-Activator>
                    <Import-Package>
                          javax.swing.*,
                          org.osgi.framework.*,
                          org.jabricks.widgets.*,
                          org.jabricks.universal.*,
                          org.jabricks.resources
                    </Import-Package>
                 </instructions>
              </configuration>
          </plugin>
      </plugins>
   </build>  
</project>