configdialog.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

                    ips.add(IPUtils.getHostAddress(anAddr));
                    sawValid = true;
                }

                if (!sawValid) {
                    modeManual = true;
                }

                // if an address was previously configured, switch to manual
                // if we do not find any interface, switch to manual too.
                if (defaultInterfaceAddr != null) {
                    InetAddress defaultIntf = InetAddress.getByName(defaultInterfaceAddr);

                    if (!IPUtils.ANYADDRESS.equals(defaultIntf)) {
                        modeManual = true;

                        // However, if this address is in the automatic list,
                        // switch back to automatic and select it.
                        allIntf = IPUtils.getAllLocalAddresses();

                        while (allIntf.hasNext()) {
                            InetAddress anAddr = allIntf.next();

                            if (defaultIntf.equals(anAddr)) {
                                modeManual = false;
                                ips.select(defaultInterfaceAddr);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                modeManual = true;
            }

            manual = new Checkbox("Manual", null, modeManual);
            add(manual);
            manual.addItemListener(this);

            addrLayout = new CardLayout();
            addrPanel = new Panel(addrLayout);

            Panel autoPanel = new Panel(new FlowLayout(FlowLayout.LEADING));

            autoPanel.add(ips);

            Panel manPanel = new Panel(new FlowLayout(FlowLayout.LEADING));

            interfaceAddr = new TextField(defaultInterfaceAddr, 20);
            manPanel.add(interfaceAddr);

            addrPanel.add(manPanel, "man");
            addrPanel.add(autoPanel, "auto");

            add(addrPanel);

            localPort = new TextField(defaultPort, 6);
            add(localPort);

            setManual(modeManual);
        }

        /**
         * {@inheritDoc}
         */
        private void setManual(boolean manMode) {
            addrLayout.show(addrPanel, manMode ? "man" : "auto");

            this.validate();
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void setEnabled(boolean enabled) {
            super.setEnabled(enabled);

            manual.setEnabled(enabled);
            ips.setEnabled(enabled);
            interfaceAddr.setEnabled(enabled);
            localPort.setEnabled(enabled);
        }

        /**
         * {@inheritDoc}
         */
        public void itemStateChanged(ItemEvent e) {
            if (e.getSource() == manual) {
                setManual(manual.getState());
            }
        }

        public String getAddress() {
            if (manual.getState()) {
                return interfaceAddr.getText().trim();
            } else {
                return ips.getSelectedItem().trim();
            }
        }

        public String getPort() {
            return localPort.getText().trim();
        }

        public String getMode() {
            return manual.getState() ? "manual" : "auto";
        }

    }


    static final class IPTptPanel extends BorderPanelGBL implements ItemListener {

        enum TransportType {
            TYPE_HTTP, TYPE_TCP
        }


        ;

        private final Checkbox useMe;
        private final Checkbox pubAddrOnly;
        private final Checkbox multicast;
        private final Checkbox clientEnabled;

        private final IfAddrPanel ifAddr;
        private final HostPortPanel publicAddr;

        public IPTptPanel(TransportType type, boolean defaultState, String name, String defaultInterfaceAddr, String defaultPort, boolean clientState, boolean serverState, String defaultPublicAddr, String defaultPublicPort, boolean pubAddrOnlyState) {
            this(type, defaultState, name, defaultInterfaceAddr, defaultPort, clientState, serverState, defaultPublicAddr
                    ,
                    defaultPublicPort, pubAddrOnlyState, false);
        }

        public IPTptPanel(TransportType type, boolean defaultState, String name, String defaultInterfaceAddr, String defaultPort, boolean clientState, boolean serverState, String defaultPublicAddr, String defaultPublicPort, boolean pubAddrOnlyState, boolean multicastState) {

            super(name);

            ifAddr = new IfAddrPanel(defaultInterfaceAddr, defaultPort);

            useMe = new Checkbox("Enabled", null, defaultState);

            if (type == TransportType.TYPE_TCP) {
                multicast = new Checkbox("Multicast", null, multicastState);
            } else {
                multicast = null;
            }

            clientEnabled = new Checkbox("Enable Outgoing connections", null, clientState);

            pubAddrOnly = new Checkbox("Hide private addresses", null, pubAddrOnlyState);

            publicAddr = new HostPortPanel("Enable Incoming Connections", "(Optional) Public address", defaultPublicAddr
                    ,
                    defaultPublicPort, serverState);

            GridBagConstraints constraints = new GridBagConstraints();

            constraints.weightx = 1.0;
            constraints.weighty = 1.0;

            constraints.gridx = 0;
            constraints.gridy = 1;
            constraints.anchor = GridBagConstraints.FIRST_LINE_START;
            add(useMe, constraints);

            if (type == TransportType.TYPE_TCP) {
                constraints.anchor = GridBagConstraints.FIRST_LINE_END;
                add(multicast, constraints);
            }

            constraints.gridx = 0;
            constraints.gridy++;
            constraints.anchor = GridBagConstraints.LINE_START;
            add(ifAddr, constraints);

            constraints.gridx = 0;
            constraints.gridy++;

            constraints.anchor = GridBagConstraints.LINE_START;
            add(clientEnabled, constraints);

            constraints.anchor = GridBagConstraints.EAST;
            add(pubAddrOnly, constraints);

            constraints.gridx = 0;
            constraints.gridy++;

            constraints.anchor = GridBagConstraints.LINE_START;
            add(publicAddr, constraints);
            publicAddr.setState(serverState);

            setState(defaultState);
            useMe.addItemListener(this);
        }

        /**
         * {@inheritDoc}
         */
        public void setState(boolean state) {
            useMe.setState(state);
            ifAddr.setEnabled(state);
            publicAddr.setEnabled(state);
            if (multicast != null) {
                multicast.setEnabled(state);
            }
            clientEnabled.setEnabled(state);
            pubAddrOnly.setEnabled(state);
        }

        /**
         * {@inheritDoc}
         */
        public void itemStateChanged(ItemEvent e) {
            setState(useMe.getState());
        }

        public String getInterfaceAddress() {
            return ifAddr.getAddress().trim();
        }

        public String getConfigMode() {
            return ifAddr.getMode();
        }

        public boolean getPubAddrOnly() {
            return pubAddrOnly.getState();
        }

        public void setPubAddrOnly(boolean state) {
            pubAddrOnly.setState(state);
        }
    }


    /**
     * Manages Peer Identity configuration
     */
    final class IdPanel extends Panel implements ActionListener {

        private final TextField peerName;
        private final TextField passwd;
        private final TextField vpasswd;

        public IdPanel(String defaultPeerName, boolean needSecurityConfig) {

            super(new GridBagLayout());

            peerName = new TextField(defaultPeerName, 20);

            GridBagConstraints constraints = new GridBagConstraints();

            constraints.gridx = 0;
            constraints.gridy = 0;
            constraints.anchor = GridBagConstraints.FIRST_LINE_END;
            add(new Label("Peer Name", Label.RIGHT), constraints);

            constraints.gridx++;
            constraints.anchor = GridBagConstraints.FIRST_LINE_START;
            add(peerName, constraints);

            if (needSecurityConfig) {
                passwd = new TextField("", 20);
                vpasswd = new TextField("", 20);
                passwd.setEchoChar('*');
                vpasswd.setEchoChar('*');

                constraints.gridx = 0;
                constraints.gridy++;
                constraints.anchor = GridBagConstraints.LINE_END;
                add(new Label("Password", Label.RIGHT), constraints);

                constraints.gridx++;
                constraints.anchor = GridBagConstraints.LINE_START;
                add(passwd, constraints);

                constraints.gridx = 0;
                constraints.gridy++;
                constraints.anchor = GridBagConstraints.LINE_END;
                add(new Label("Verify Password", Label.RIGHT), constraints);

                constraints.gridx++;
                constraints.anchor = GridBagConstraints.LINE_START;
                add(vpasswd, constraints);
            } else {
                passwd = null;
                vpasswd = null;
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public String getName() {
            return peerName.getText().trim();
        }

        public String getPassword() {
            return passwd.getText();
        }

        public String getVerifyPassword() {
            return vpasswd.getText();
        }

        public void clearPasswords() {
            passwd.setText("");
            vpasswd.setText("");
        }

        /**
         * {@inheritDoc}
         */
        public void actionPerformed(ActionEvent e) {
        }
    }


    /**
     * Manages Service Enabling
     */
    final static class EnablingPanel extends BorderPanelGBL {

        private final Checkbox isRelay;
        private final Checkbox isRendezvous;
        private final Checkbox isJxmeProxy;

        EnablingPanel(boolean actAsRelay, boolean actAsRendezvous, boolean actAsJxmeProxy) {
            super("Services Settings");

            isRelay = new Checkbox("Act as a Relay", null, actAsRelay);
            isRendezvous = new Checkbox("Act as a Rendezvous", null, actAsRendezvous);
            isJxmeProxy = new Checkbox("Act as a JXME proxy", null, actAsJxmeProxy);

            add(isRelay, stdConstr);
            add(isRendezvous, stdConstr);
            add(isJxmeProxy, stdConstr);
        }
    }


    /**
     * Manages Rendezvous service options
     */
    final static class RdvPanel extends BorderPanelGBL implements ItemListener {

        private final Checkbox useRdv;
        private final Checkbox useOnlySeeds;
        private final HostListPanel seeding;
        private final HostListPanel seeds;

        RdvPanel(boolean useARdv, boolean onlySeeds) {
            super("Rendezvous Settings");

            useRdv = new Checkbox("Use a rendezvous", null, useARdv);
            useOnlySeeds = new Checkbox("Use only configured seeds", null, onlySeeds);
            seeds = new HostListPanel("Seeds", "Rendezvous seed peers", true, false);
            seeding = new HostListPanel("Seeding", "Rendezvous seeding URIs", true, false);

            GridBagConstraints c1 = new GridBagConstraints();

            c1.gridx = 0;
            c1.gridy = 0;
            c1.anchor = GridBagConstraints.LINE_START;
            add(useRdv, c1);
            useRdv.addItemListener(this);

            c1.gridx++;
            c1.anchor = GridBagConstraints.LINE_END;
            add(useOnlySeeds, c1);

            c1.gridx = 0;
            c1.gridy++;
            c1.gridwidth = 2;
            c1.weightx = 1.0;
            c1.fill = GridBagConstraints.HORIZONTAL;
            c1.anchor = GridBagConstraints.LINE_START;
            add(seeding, c1);

            c1.gridy++;
            add(seeds, c1);
        }

        /**
         * {@inheritDoc}
         */
        public void itemStateChanged(ItemEvent e) {
            seeds.setEnabled(useRdv.getState());
            seeding.setEnabled(useRdv.getState());
            useOnlySeeds.setEnabled(useRdv.getState());
        }
    }