Subversion Repositories DevTools

/**

 * AntShield - A project release tool for ant.

 */

package com.erggroup.mass.ant;

import javax.swing.*;

import javax.swing.border.EtchedBorder;

import java.util.*;

import java.awt.*;

import java.awt.event.*;

/**

 * AntShieldReleaseFrame

 * A dialog box that allows users to select an allowed project

 * and release for a specified package.

 */

public class AntShieldReleaseFrame extends JFrame {

    private String name = null;

    private String type = null;

    private String project = new String();

    private String release = new String();

    private String releaseLabelString;

    private String titleString;

    private ArrayList projects = new ArrayList();

    private ArrayList releases = new ArrayList();

    private JComboBox projectBox = new JComboBox();

    private JComboBox releaseBox = new JComboBox();

    private boolean ok = false;

    private boolean undo = false;

    private AntShieldLock lock = new AntShieldLock();

    /**

     * Constructor.  Populate projects and releases with supplied

     * parameters, build the dialog box, and display self.

     * @param pkgname

     * @param reltype

     * @param rellist

     */

    public AntShieldReleaseFrame(String pkgname, String reltype, ArrayList rellist, boolean undoflag)

    {

        name = pkgname;

        type = reltype;

        undo = undoflag;

        if (undo)

        {

            titleString = new String("Antshield Existing Release - Package \"" + name + "\"");

            releaseLabelString = new String("Existing release");

        }

        else

        {

            titleString = new String("Antshield New Release - Package \"" + name + "\"");

            releaseLabelString = new String("New release");

        }

        Iterator i = rellist.iterator();

        while (i.hasNext())

        {

            String rel = (String)i.next();

            String proj = rel.substring(rel.lastIndexOf(".")+1).trim();

            releases.add(rel);

            int n = projects.size();

            boolean haveIt = false;

            for (int j = 0; j < n; j++)

            {

                String s = (String)projects.get(j);

                if (s.equals(proj))

                {

                    haveIt = true;

                    break;

                }

            }

            if (!haveIt)

            {

                projects.add(proj);

            }

        }

        init();

        setPosition();

        updateProjects();

        updateReleases();

        pack();

        setVisible(true);

        lock.acquire();

    }

    /**

     * Build this frame from components.

     */

    private void init()

    {

        setTitle(titleString);

        // Proper close if the user closes the window.

        addWindowListener(new AntShieldReleaseWindowClose(this));

        // OK button.

        JButton okButton = new JButton();

        okButton.setActionCommand("OK");

        okButton.setText("OK");

        okButton.addActionListener(new AntShieldReleaseOKAction(this));

        // Cancel button.

        JButton cancelButton = new JButton();

        cancelButton.setActionCommand("Cancel");

        cancelButton.setText("Cancel");

        cancelButton.addActionListener(new AntShieldReleaseCancelAction(this));

        // Labels.

        JLabel projectLabel = new JLabel("Project");

        projectLabel.setPreferredSize(new Dimension(120, 25));

        JLabel typeLabel = new JLabel("Release Type");

        typeLabel.setPreferredSize(new Dimension(120, 25));

        JLabel releaseLabel = new JLabel(releaseLabelString);

        releaseLabel.setPreferredSize(new Dimension(120, 25));

        // Handle changes in project combo box.

        projectBox.addActionListener(new AntShieldReleaseProjectAdapter(this));

        // Allow user entry in project combo box.

        projectBox.setEditable(true);

        // Allow user entry in release combo box.

        releaseBox.setEditable(true);

        // Release-type radio buttons.

        JRadioButton majorButton = new JRadioButton("Major");

        majorButton.addActionListener(new AntShieldReleaseMajorAdapter(this));

        JRadioButton minorButton = new JRadioButton("Minor");

        minorButton.addActionListener(new AntShieldReleaseMinorAdapter(this));

        JRadioButton patchButton = new JRadioButton("Patch");

        patchButton.addActionListener(new AntShieldReleasePatchAdapter(this));

        ButtonGroup typeGroup = new ButtonGroup();

        typeGroup.add(majorButton);

        typeGroup.add(minorButton);

        typeGroup.add(patchButton);

        if (type.equals("major"))

          majorButton.setSelected(true);

        else if (type.equals("minor"))

          minorButton.setSelected(true);

        else

          patchButton.setSelected(true);

        // Release-type panel.

        JPanel typePanel = new JPanel();

        typePanel.setLayout(new GridLayout(3,1));

        typePanel.setBorder(new EtchedBorder());

        typePanel.add(majorButton);

        typePanel.add(minorButton);

        typePanel.add(patchButton);

        // South-east panel - holds the OK and Cancel buttons.

        JPanel sePanel = new JPanel();

        sePanel.add(okButton, null);

        sePanel.add(cancelButton, null);

        // South panel - holds south-east panel

        JPanel southPanel = new JPanel();

        southPanel.setLayout(new BorderLayout());

        southPanel.setBorder(new EtchedBorder());

        southPanel.add(sePanel, BorderLayout.EAST);

        // Format everything with nice indentation

        Box box2 = new Box(BoxLayout.X_AXIS);

        box2.add(Box.createHorizontalStrut(50));

        box2.add(projectLabel);

        box2.add(Box.createHorizontalStrut(10));

        box2.add(projectBox);

        box2.add(Box.createHorizontalStrut(50));

        Box box3 = new Box(BoxLayout.X_AXIS);

        if (!undo)

        {

            box3.add(Box.createHorizontalStrut(50));

            box3.add(typeLabel);

            box3.add(Box.createHorizontalStrut(10));

            box3.add(typePanel);

            box3.add(Box.createHorizontalStrut(50));

        }

        Box box4 = new Box(BoxLayout.X_AXIS);

        box4.add(Box.createHorizontalStrut(50));

        box4.add(releaseLabel);

        box4.add(Box.createHorizontalStrut(10));

        box4.add(releaseBox);

        box4.add(Box.createHorizontalStrut(50));

        Box box5 = new Box(BoxLayout.Y_AXIS);

        box5.add(Box.createVerticalStrut(50));

        box5.add(box2);

        box5.add(Box.createVerticalStrut(10));

        box5.add(box3);

        box5.add(Box.createVerticalStrut(10));

        box5.add(box4);

        box5.add(Box.createVerticalStrut(50));

        // Keep our components centred and top-justified

        JPanel centrePanel = new JPanel();

        centrePanel.setLayout(new BorderLayout());

        centrePanel.setBorder(new EtchedBorder());

        centrePanel.add(box5, BorderLayout.NORTH);

        getContentPane().setLayout(new BorderLayout());

        getContentPane().add(southPanel, BorderLayout.SOUTH);

        getContentPane().add(centrePanel, BorderLayout.CENTER);

        // Hitting ENTER activates the OK button

        getRootPane().setDefaultButton(okButton);

        pack();

    } // init

    /**

     * Position this frame in the centre of the screen,

     * resizing if necessary.

     */

    private void setPosition()

    {

        int scrnWidth = Toolkit.getDefaultToolkit().getScreenSize().width;

        int scrnHeight = Toolkit.getDefaultToolkit().getScreenSize().height;

        int width = getWidth();

        int height = getHeight();

        if (width > scrnWidth/2)

        {

            width = scrnWidth/2;

        }

        if (width < scrnWidth/8)

        {

            width = scrnWidth/8;

        }

        if (height > scrnHeight/2)

        {

            height = scrnHeight/2;

        }

        if (height < scrnHeight/8)

        {

            height = scrnHeight/8;

        }

        setSize(width, height);

        int xpos = scrnWidth/2 - width/2;

        int ypos = scrnHeight/2 - height/2;

        setLocation(xpos, ypos);

    } // setPosition

    /**

     * Handle the OK button by verifying everything.  Pop up

     * a dialog if all isn't well.

     */

    public void handleOk()

    {

        String proj = (String)projectBox.getSelectedItem();

        String rel = (String)releaseBox.getSelectedItem();

        if ((proj == null) || (proj.trim().length() < 1))

        {

            new AntShieldRetryDialog("A project must be specified.");

        }

        else if ((rel == null) || (rel.trim().length() < 1))

        {

            new AntShieldRetryDialog("A release must be specified.");

        }

        else if (!verifyReleaseNumber()) //ignore this if in undo mode

        {

            String msg = new String("Release '");

            msg += rel;

            msg += "' is invalid for project '";

            msg += proj;

            msg += "'.";

            new AntShieldRetryDialog(msg);

        }

        else

        {

            ok = true;

            close();

        }

    } // handleOk

    /**

     * Handle the cancel button.

     */

    public void handleCancel()

    {

        ok = false;

        close();

    } // handleCancel

    /**

     * Handle changes to the project combo box, especially

     * trimming any manually entered project to 3 characters max.

     */

    public void handleProject() {

        project = ((String)projectBox.getSelectedItem()).trim();

        if (!projects.contains(project) && (project.length() > 3))

        {

            project = project.substring(0, 3);

            projectBox.setSelectedItem(project);

        }

        updateReleases();

    } // handleProject

    /**

     * Handle the major radio button.

     * Change the release type to major.

     */

    public void handleMajor() {

        type = "major";

        updateReleases();

    } // handleMajor

    /**

     * Handle the minor radio button.

     * Change the release type to minor.

     */

    public void handleMinor() {

        type = "minor";

        updateReleases();

    } // handleMinor

    /**

     * Handle the patch radio button.

     * Change the release type to patch.

     */

    public void handlePatch() {

        type = "patch";

        updateReleases();

    } // handlePatch

    /**

     * Return the selected release in the form "x.y.z.proj".

     * @return

     */

    public String getRelease()

    {

        return release;

    } // getRelease

    /**

     * Did we exit successfully?

     * @return

     */

    public boolean isOk()

    {

        return ok;

    } // isOk

    /**

     * Close this frame.

     */

    public void close()

    {

        lock.release();

        setVisible(false);

    } // close

    /**

     * Check that the currently selected release is of the form

     * "<int>.<int>.<int>", and that it isn't already in the list

     * of existing releases (unless undo is true).

     * @return

     */

    private boolean verifyReleaseNumber()

    {

        boolean status = false;

        String s = (String)releaseBox.getSelectedItem();

        int i1 = s.indexOf('.');

        int i2 = s.indexOf('.', i1+1);

        if ((i1 > 0) && (i2 > i1) && (s.lastIndexOf('.') == i2))

        {

            try

            {

                Integer major = new Integer(s.substring(0, i1).trim());

                Integer minor = new Integer(s.substring(i1+1, i2).trim());

                Integer patch = new Integer(s.substring(i2+1).trim());

                release = new String();

                release += major.toString();

                release += ".";

                release += minor.toString();

                release += ".";

                release += patch.toString();

                release += ".";

                release += project;

                if (undo)

                {

//                     if ((release.indexOf('-') < 0) && releases.contains(release))

//                     {

                         status = true;

//                     }

                }

                else

                {

                    if ((release.indexOf('-') < 0) && !releases.contains(release) && !release.substring(0,5).equals("0.0.0"))

                    {

                        status = true;

                    }

                }

            }

            catch (NumberFormatException e)

            {

                ;  // do nothing

            }

        }

        return status;

    } // verifyReleaseNumber

    /**

     * Populate the project combo box.

     */

    private void updateProjects()

    {

        projectBox.removeAllItems();

        Iterator i = projects.iterator();

        while (i.hasNext())

        {

            projectBox.addItem(i.next());

        }

        project = (String)projectBox.getSelectedItem();

    } // updateProjects

    /**

     * Populate the release combo box with the allowed releases

     * (if any) for the current project and release type.  Select

     * the highest release by default.

     */

    private void updateReleases()

    {

        releaseBox.removeAllItems();

        if ((project != null) && (project.length() > 0))

        {

            if (undo)

                updateUndoReleases();

            else if (type.equals("major"))

                updateMajorReleases();

            else if (type.equals("minor"))

                updateMinorReleases();

            else

                updatePatchReleases();

        }

        if (releaseBox.getItemCount() > 0)

        {

            releaseBox.setSelectedIndex(releaseBox.getItemCount()-1);

        }

    } // updateReleases

    /**

     * Populate the release combo box with the allowed undo releases

     * for the current project.

     */

    private void updateUndoReleases()

    {

        TreeSet set = new TreeSet();

        Iterator i = releases.iterator();

        while (i.hasNext())

        {

            String s = (String)i.next();

            int j = s.lastIndexOf('.')+1;

            String proj = s.substring(j).trim();

            if (proj.equals(project))

            {

                set.add(s.substring(0, j-1).trim());

                //releaseBox.addItem(s.substring(0, j-1).trim());

            }

        }

        i = set.iterator();

        while (i.hasNext())

        {

            releaseBox.addItem(i.next());

        }

    } // updateUndoReleases

    /**

     * Populate the release combo box with the allowed major release

     * for the current project.

     */

    private void updateMajorReleases()

    {

        int currentMajor = 0;

        Iterator i = releases.iterator();

        while (i.hasNext())

        {

            String s = (String)i.next();

            String proj = s.substring(s.lastIndexOf('.')+1).trim();

            if (proj.equals(project))

            {

                int m = new Integer(s.substring(0,s.indexOf('.')).trim()).intValue();

                if (m > currentMajor)

                    currentMajor = m;

            }

        }

        String r = new String(new Integer(currentMajor+1).toString());

        r += ".0.0";

        releaseBox.addItem(r);

    } // updateMajorReleases

    /**

     * Populate the release combo box with the allowed minor releases

     * for the current project.

     */

    private void updateMinorReleases()

    {

        TreeMap majors = new TreeMap();

        Iterator i = releases.iterator();

        while (i.hasNext())

        {

            String s = (String)i.next();

            String proj = s.substring(s.lastIndexOf('.')+1).trim();

            if (proj.equals(project))

            {

                int i1 = s.indexOf('.');

                int i2 = s.indexOf('.', i1+1);

                Integer k = new Integer(s.substring(0, i1).trim());

                Integer v = new Integer(s.substring(i1+1, i2).trim());

                if (majors.containsKey(k))

                {

                    Integer w = (Integer)majors.get(k);

                    if (w.intValue() < v.intValue())

                    {

                        majors.put(k, v);

                    }

                }

                else

                {

                    majors.put(k, v);

                }

            }

        }

        Set kset = majors.keySet();

        Iterator j = kset.iterator();

        while (j.hasNext())

        {

            Integer k = (Integer)j.next();

            String r = k.toString();

            r += ".";

            r += new Integer(((Integer)majors.get(k)).intValue() + 1).toString();

            r += ".0";

            releaseBox.addItem(r);

        }

        if (releaseBox.getItemCount() == 0)

        {

            releaseBox.addItem(new String("0.1.0"));

        }

    } // updateMinorReleases

    /**

     * Populate the release combo box with the allowed patch releases

     * (if any) for the current project.

     */

    private void updatePatchReleases()

    {

        TreeMap majors = new TreeMap();

        Iterator i = releases.iterator();

        while (i.hasNext())

        {

            String s = (String)i.next();

            String proj = s.substring(s.lastIndexOf('.')+1).trim();

            if (proj.equals(project))

            {

                int i1 = s.indexOf('.');

                int i2 = s.indexOf('.', i1+1);

                int i3 = s.indexOf('.', i2+1);

                Integer maj = new Integer(s.substring(0, i1).trim());

                Integer min = new Integer(s.substring(i1+1, i2).trim());

                Integer pat = new Integer(s.substring(i2+1, i3).trim());

                if (majors.containsKey(maj))

                {

                    TreeMap minors = (TreeMap)majors.get(maj);

                    if (minors.containsKey(min))

                    {

                        Integer w = (Integer)minors.get(min);

                        if (w.intValue() < pat.intValue())

                        {

                            minors.put(min, pat);

                        }

                    }

                    else

                    {

                        minors.put(min, pat);

                    }

                }

                else

                {

                    TreeMap minors = new TreeMap();

                    minors.put(min, pat);

                    majors.put(maj, minors);

                }

            }

        }

        Set kset1 = majors.keySet();

        Iterator j1 = kset1.iterator();

        while (j1.hasNext())

        {

            Integer maj = (Integer)j1.next();

            TreeMap minors = (TreeMap)majors.get(maj);

            Set kset2 = minors.keySet();

            Iterator j2 = kset2.iterator();

            while (j2.hasNext())

            {

                Integer min = (Integer)j2.next();

                String r = new String(maj.toString());

                r += ".";

                r += min.toString();

                r += ".";

                r += new Integer(((Integer)minors.get(min)).intValue() + 1).toString();

                releaseBox.addItem(r);

            }

        }

        if (releaseBox.getItemCount() == 0)

        {

            releaseBox.addItem(new String("0.0.1"));

        }

    } // updatePatchReleases

}

class AntShieldReleaseMajorAdapter implements ActionListener

{

    private AntShieldReleaseFrame adaptee;

    public AntShieldReleaseMajorAdapter(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handleMajor();

    }

}

class AntShieldReleaseMinorAdapter implements ActionListener

{

    private AntShieldReleaseFrame adaptee;

    public AntShieldReleaseMinorAdapter(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handleMinor();

    }

}

class AntShieldReleasePatchAdapter implements ActionListener

{

    private AntShieldReleaseFrame adaptee;

    public AntShieldReleasePatchAdapter(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handlePatch();

    }

}

class AntShieldReleaseProjectAdapter implements ActionListener

{

    private AntShieldReleaseFrame adaptee;

    public AntShieldReleaseProjectAdapter(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handleProject();

    }

}

class AntShieldReleaseOKAction implements ActionListener

{

    AntShieldReleaseFrame adaptee;

    public AntShieldReleaseOKAction(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handleOk();

    }

}

class AntShieldReleaseCancelAction implements ActionListener

{

    AntShieldReleaseFrame adaptee;

    public AntShieldReleaseCancelAction(AntShieldReleaseFrame a)

    {

        adaptee = a;

    }

    public void actionPerformed(ActionEvent e)

    {

        adaptee.handleCancel();

    }

}

class AntShieldReleaseWindowClose extends WindowAdapter

{

    private AntShieldReleaseFrame parent;

    public AntShieldReleaseWindowClose(AntShieldReleaseFrame a)

    {

        parent = a;

    }

    public void windowClosing(WindowEvent e)

    {

        parent.close();

    }

}