Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

/**

 * Unit test for simple App.

 */

public class AppTest extends TestCase {

    /**

     * @return the suite of tests being tested

     */

    public static Test suite() {

        return new TestSuite(AppTest.class);

    }

    /**

     * Create the test case

     * 

     * @param testName

     *            name of the test case

     */

    public AppTest(String testName) {

        super(testName);

    }

    /**

     * Rigourous Test :-)

     */

    public void testApp() {

        assertTrue(true);

    }

}

org.gvsig.tools.swing.impl.ToolsSwingDefaultImplLibrary

package org.gvsig.tools.swing.impl;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.beans.Transient;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.Vector;

import javax.accessibility.AccessibleContext;

import javax.swing.DefaultListSelectionModel;

import javax.swing.JList;

import javax.swing.ListCellRenderer;

import javax.swing.ListModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.plaf.ListUI;

import javax.swing.text.Position;

import org.gvsig.tools.swing.api.DefaultCheckListCellRenderer;

import org.gvsig.tools.swing.api.JListWithCheckbox;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultJListWithCheckbox extends JListWithCheckbox {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultJListWithCheckbox.class);

    private final JList wrappedList;

    private ListSelectionModel checkedsModel = new DefaultListSelectionModel();

    private Set<ListSelectionListener> checkedsListeners;

    private final ListSelectionListener checksModelListener;

    private final DefaultCheckListCellRenderer checkListCellRenderer;

    public DefaultJListWithCheckbox(final JList wrappedList) {

        this.wrappedList = wrappedList;

        this.checkedsModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        this.checkedsListeners = new HashSet<>();

        this.checkListCellRenderer = new DefaultCheckListCellRenderer(

                this.wrappedList.getCellRenderer(),

                this.checkedsModel

        );

        this.wrappedList.setCellRenderer(this.checkListCellRenderer);

        this.wrappedList.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent me) {

                int index = wrappedList.locationToIndex(me.getPoint());

                if (index < 0) {

                    return;

                }

                ListCellRenderer renderer = wrappedList.getCellRenderer();

                int checkBoxWidth = 16;

                if(renderer instanceof DefaultCheckListCellRenderer){

                    checkBoxWidth = ((DefaultCheckListCellRenderer)renderer).getCheckBoxWidth();

                }

                if (me.getX() > wrappedList.getCellBounds(index, index).getX() + checkBoxWidth) {

                    return;

                }

                toggleCheck(index);

            }

        });

        this.checksModelListener = new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent lse) {

                wrappedList.repaint();

                //fireCheckedsListeners(lse);

            }

        };

        this.setCheckedModel(checkedsModel);

    }

    @Override

    public final void setCheckedModel(ListSelectionModel checkedsModel) {

        this.checkedsModel.removeListSelectionListener(this.checksModelListener);

        this.checkedsModel = checkedsModel;

        this.checkedsModel.addListSelectionListener(this.checksModelListener);

        this.checkListCellRenderer.setCheckedModel(checkedsModel);

    }

    @Override

    public void toggleCheck(int index) {

        if (index < 0) {

            return;

        }

        if (this.checkedsModel.isSelectedIndex(index)) {

            this.checkedsModel.removeSelectionInterval(index, index);

        } else {

            this.checkedsModel.addSelectionInterval(index, index);

        }

        // FIXME: isAdjusting is set to false always

        fireCheckedsListeners(new ListSelectionEvent(this, index, index, false));

    }

    @Override

    public ListUI getUI() {

        return this.wrappedList.getUI();

    }

    @Override

    public void setUI(ListUI ui) {

        this.wrappedList.setUI(ui);

    }

    @Override

    public void updateUI() {

        if( this.wrappedList!= null ) {

            this.wrappedList.updateUI();

        }

    }

    @Override

    public String getUIClassID() {

        return this.wrappedList.getUIClassID();

    }

    @Override

    public Object getPrototypeCellValue() {

        return this.wrappedList.getPrototypeCellValue();

    }

    @Override

    public void setPrototypeCellValue(Object prototypeCellValue) {

        this.wrappedList.setPrototypeCellValue(prototypeCellValue);

    }

    @Override

    public int getFixedCellWidth() {

        return this.wrappedList.getFixedCellWidth();

    }

    @Override

    public void setFixedCellWidth(int width) {

        this.wrappedList.setFixedCellWidth(width);

    }

    @Override

    public int getFixedCellHeight() {

        return this.wrappedList.getFixedCellHeight();

    }

    @Override

    public void setFixedCellHeight(int height) {

        this.wrappedList.setFixedCellHeight(height);

    }

    @Transient

    @Override

    public ListCellRenderer getCellRenderer() {

        return this.wrappedList.getCellRenderer();

    }

    @Override

    public void setCellRenderer(ListCellRenderer cellRenderer) {

        this.wrappedList.setCellRenderer(cellRenderer);

    }

    @Override

    public Color getSelectionForeground() {

        return this.wrappedList.getSelectionForeground();

    }

    @Override

    public void setSelectionForeground(Color selectionForeground) {

        this.wrappedList.setSelectionForeground(selectionForeground);

    }

    @Override

    public Color getSelectionBackground() {

        return this.wrappedList.getSelectionBackground();

    }

    @Override

    public void setSelectionBackground(Color selectionBackground) {

        this.wrappedList.setSelectionBackground(selectionBackground);

    }

    @Override

    public int getVisibleRowCount() {

        return this.wrappedList.getVisibleRowCount();

    }

    @Override

    public void setVisibleRowCount(int visibleRowCount) {

        this.wrappedList.setVisibleRowCount(visibleRowCount);

    }

    @Override

    public int getLayoutOrientation() {

        return this.wrappedList.getLayoutOrientation();

    }

    @Override

    public void setLayoutOrientation(int layoutOrientation) {

        this.wrappedList.setLayoutOrientation(layoutOrientation);

    }

    @Override

    public int getFirstVisibleIndex() {

        return this.wrappedList.getFirstVisibleIndex();

    }

    @Override

    public int getLastVisibleIndex() {

        return this.wrappedList.getLastVisibleIndex();

    }

    @Override

    public void ensureIndexIsVisible(int index) {

        this.wrappedList.ensureIndexIsVisible(index);

    }

    @Override

    public void setDragEnabled(boolean b) {

        this.wrappedList.setDragEnabled(b);

    }

    @Override

    public boolean getDragEnabled() {

        return this.wrappedList.getDragEnabled();

    }

//

//    public final void setDropMode(DropMode dropMode) {

//        this.wrappedList.setDropMode(dropMode);

//    }

//

//    public final DropMode getDropMode() {

//        

//    }

//

//    public final DropLocation getDropLocation() {

//        

//    }

    @Override

    public int getNextMatch(String prefix, int startIndex, Position.Bias bias) {

        return this.wrappedList.getNextMatch(prefix, startIndex, bias);

    }

    @Override

    public String getToolTipText(MouseEvent event) {

        return this.wrappedList.getToolTipText(event);

    }

    @Override

    public int locationToIndex(Point location) {

        return this.wrappedList.locationToIndex(location);

    }

    @Override

    public Point indexToLocation(int index) {

        return this.wrappedList.indexToLocation(index);

    }

    @Override

    public Rectangle getCellBounds(int index0, int index1) {

        return this.wrappedList.getCellBounds(index0, index1);

    }

    @Override

    public ListModel getModel() {

        return this.wrappedList.getModel();

    }

    @Override

    public void setModel(ListModel model) {

        this.wrappedList.setModel(model);

    }

    @Override

    public void setListData(Object[] listData) {

        this.wrappedList.setListData(listData);

    }

    @Override

    public void setListData(Vector listData) {

        this.wrappedList.setListData(listData);

    }

    @Override

    public ListSelectionModel getSelectionModel() {

        return this.wrappedList.getSelectionModel();

    }

    @Override

    public ListSelectionModel getCheckedModel() {

        return this.checkedsModel;

    }

    @Override

    public void addListSelectionListener(ListSelectionListener listener) {

        this.wrappedList.addListSelectionListener(listener);

    }

    @Override

    public void addChecksListener(ListSelectionListener listener) {

       this.checkedsListeners.add(listener);

    }

    @Override

    public void removeListSelectionListener(ListSelectionListener listener) {

        this.wrappedList.removeListSelectionListener(listener);

    }    

    @Override

    public void removeChecksListener(ListSelectionListener listener) {

        this.checkedsListeners.remove(listener);

    }

    @Override

    public ListSelectionListener[] getListSelectionListeners() {

        return this.wrappedList.getListSelectionListeners();

    }

    @Override

    public ListSelectionListener[] getChecksListeners() {

        return this.checkedsListeners.toArray(new ListSelectionListener[1]);

    }

    protected void fireCheckedsListeners(ListSelectionEvent event) {

        Iterator<ListSelectionListener> it = this.checkedsListeners.iterator();

        while(it.hasNext()) {

            ListSelectionListener listener = it.next();

            try {

                listener.valueChanged(event);

            } catch(Throwable th) {

                LOGGER.warn("Problems calling check listener ("+listener+").",th);

            }

        }

    }

    @Override

    public void setSelectionModel(ListSelectionModel selectionModel) {

        this.wrappedList.setSelectionModel(selectionModel);

    }

    @Override

    public void setSelectionMode(int selectionMode) {

        this.wrappedList.setSelectionMode(selectionMode);

    }

    @Override

    public int getSelectionMode() {

        return this.wrappedList.getSelectionMode();

    }

    @Override

    public int getAnchorSelectionIndex() {

        return this.wrappedList.getAnchorSelectionIndex();

    }

    @Override

    public int getLeadSelectionIndex() {

        return this.wrappedList.getLeadSelectionIndex();

    }

    @Override

    public int getMinSelectionIndex() {

        return this.wrappedList.getMinSelectionIndex();

    }

    @Override

    public int getMaxSelectionIndex() {

        return this.wrappedList.getMaxSelectionIndex();

    }

    @Override

    public boolean isSelectedIndex(int index) {

        return this.wrappedList.isSelectedIndex(index);

    }

    @Override

    public boolean isSelectionEmpty() {

        return this.wrappedList.isSelectionEmpty();

    }

    @Override

    public void clearSelection() {

        this.wrappedList.clearSelection();

    }

    @Override

    public void setSelectionInterval(int anchor, int lead) {

        this.wrappedList.setSelectionInterval(anchor, lead);

    }

    @Override

    public void addSelectionInterval(int anchor, int lead) {

        this.wrappedList.addSelectionInterval(anchor, lead);

    }

    @Override

    public void removeSelectionInterval(int index0, int index1) {

        this.wrappedList.removeSelectionInterval(index0, index1);

    }

    @Override

    public void setValueIsAdjusting(boolean b) {

        this.wrappedList.setValueIsAdjusting(b);

    }

    @Override

    public boolean getValueIsAdjusting() {

        return this.wrappedList.getValueIsAdjusting();

    }

    @Transient

    @Override

    public int[] getSelectedIndices() {

        return this.wrappedList.getSelectedIndices();

    }

    @Override

    public void setSelectedIndex(int index) {

        this.wrappedList.setSelectedIndex(index);

    }

    @Override

    public void setSelectedIndices(int[] indices) {

        this.wrappedList.setSelectedIndices(indices);

    }

    @Deprecated

    @Override

    public Object[] getSelectedValues() {

        return this.wrappedList.getSelectedValues();

    }

    @Override

    public List getSelectedValuesList() {

        return this.wrappedList.getSelectedValuesList();

    }

    @Override

    public int getSelectedIndex() {

        return this.wrappedList.getSelectedIndex();

    }

    @Override

    public Object getSelectedValue() {

        return this.wrappedList.getSelectedValue();

    }

    @Override

    public void setSelectedValue(Object anObject, boolean shouldScroll) {

        this.wrappedList.setSelectedValue(anObject, shouldScroll);

    }

    @Override

    public Dimension getPreferredScrollableViewportSize() {

        return this.wrappedList.getPreferredScrollableViewportSize();

    }

    @Override

    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {

        return this.wrappedList.getScrollableUnitIncrement(visibleRect, orientation, direction);

    }

    @Override

    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {

        return this.wrappedList.getScrollableBlockIncrement(visibleRect, orientation, direction);

    }

    @Override

    public boolean getScrollableTracksViewportWidth() {

        return this.wrappedList.getScrollableTracksViewportWidth();

    }

    @Override

    public boolean getScrollableTracksViewportHeight() {

        return this.wrappedList.getScrollableTracksViewportHeight();

    }

    @Override

    public AccessibleContext getAccessibleContext() {

        return this.wrappedList.getAccessibleContext();

    }

}

package org.gvsig.tools.swing.impl;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.ImageIcon;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.swing.api.MessageBarController;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author omartinez

 */

public class MessageBarControllerImpl implements MessageBarController {

    private JLabel label;

    private int time;

    private final Timer timer;

    private static final Logger LOGGER = LoggerFactory.getLogger(MessageBarControllerImpl.class);

    public MessageBarControllerImpl(JLabel label, int time) {

        this.label = label;

        this.time = time;

        this.timer = this.buildTimer();

    }

    private Timer buildTimer() {

        Timer newTimer;

        newTimer = new Timer(this.time, new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                try {

                    clear();

                } catch (Throwable ex) {

                    LOGGER.info("Can't clear message", ex);

                }

            }

        });

        return newTimer;

    }

    private String toHTML(String s) {

        s = StringUtils.replace(s, "\n", "\n<br>");

        s = StringUtils.replace(s, "<html>", "");

        s = StringUtils.replace(s, "</html>", "");

        s = "<html>" + s + "</html>";

        return s;

    }

    @Override

    public void setTime(int time) {

        this.time = time;

        this.timer.setDelay(this.time);

    }

    @Override

    public void setText(String msg, int messageType) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    setText(msg, messageType);

                }

            });

            return;

        }

        timer.stop();

        if (StringUtils.isBlank(msg)) {

            this.clear();

            return;

        }

        label.setText(toHTML(msg));

        label.paintImmediately(label.getVisibleRect());

        label.paintImmediately(label.getVisibleRect());

        timer.start();

    }

    @Override

    public void setText(String text) {

        this.setText(text, -1);

    }

    @Override

    public void clear() {

        this.label.setText("");

    }

}

package org.gvsig.tools.swing.impl;

import org.gvsig.tools.swing.api.CompoundIcon;

import java.awt.Component;

import java.awt.Graphics;

import javax.swing.Icon;

import javax.swing.SwingConstants;

/*

 * Based on portions of code from CompoundIcon of Rob Camick 

 * Posted on March 29, 2009 in Java Tips Weblog.

 * https://tips4java.wordpress.com/2009/03/29/compound-icon/

 */

/**

 * The CompoundIcon will paint two, or more, Icons as a single Icon. The Icons

 * are painted in the order in which they are added.

 *

 * The Icons are layed out on the specified axis:

 * <ul>

 * <li>X-Axis (horizontally)

 * <li>Y-Axis (vertically)

 * <li>Z-Axis (stacked)

 * </ul>

 *

 */

public class DefaultCompoundIcon implements CompoundIcon {

    private Icon[] icons;

    private int orientation;

    private int gap;

    private int alignmentX = SwingConstants.CENTER;

    private int alignmentY = SwingConstants.CENTER;

    /**

     * Convenience contructor for creating a CompoundIcon where the icons are

     * layed out HORIZONTAL, the gap is 0 and the X/Y alignments will

     * default to CENTER.

     *

     * @param icons the Icons to be painted as part of the CompoundIcon

     */

    public DefaultCompoundIcon(Icon... icons) {

        this(SwingConstants.HORIZONTAL, icons);

    }

    /**

     * Convenience contructor for creating a CompoundIcon where the gap is 0 and

     * the X/Y alignments will default to CENTER.

     *

     * @param orientation the orientation used to lay out the icons for painting. 

     * Must be one of SwingConstants.HORIZONTAL, SwingConstants.VERTICAL or STACKED.

     * @param icons the Icons to be painted as part of the CompoundIcon

     */

    public DefaultCompoundIcon(int orientation, Icon... icons) {

        this(orientation, 0, icons);

    }

    /**

     * Convenience contructor for creating a CompoundIcon where the X/Y

     * alignments will default to CENTER.

     *

     * @param orientation the orientation used to lay out the icons for painting. 

     * Must be one of SwingConstants.HORIZONTAL, SwingConstants.VERTICAL or STACKED.

     * @param gap the gap between the icons

     * @param icons the Icons to be painted as part of the CompoundIcon

     */

    public DefaultCompoundIcon(int orientation, int gap, Icon... icons) {

        this(orientation, gap, SwingConstants.CENTER, SwingConstants.CENTER, icons);

    }

    /**

     * Create a CompoundIcon specifying all the properties.

     *

     * @param orientation the orientation used to lay out the icons for painting. 

     * Must be one of SwingConstants.HORIZONTAL, SwingConstants.VERTICAL or STACKED.

     * @param gap the gap between the icons

     * @param alignmentX the X alignment of the icons. Common values are LEFT,

     * CENTER, RIGHT.

     * @param alignmentY the Y alignment of the icons. Common values are TOP,

     * CENTER, BOTTOM.

     * @param icons the Icons to be painted as part of the CompoundIcon

     */

    public DefaultCompoundIcon(int orientation, int gap, int alignmentX, int alignmentY, Icon... icons) {

        switch (orientation) {

            case SwingConstants.HORIZONTAL:

            case SwingConstants.VERTICAL:

            case STACKED:

                break;

            default:

                throw new IllegalArgumentException("Incorrent value '" + orientation + "' of orientation.");

        }

        switch (alignmentX) {

            case SwingConstants.CENTER:

            case SwingConstants.LEFT:

            case SwingConstants.RIGHT:

                break;

            default:

                throw new IllegalArgumentException("Incorrent value '" + alignmentX + "' of AlignmentX.");

        }

        switch (alignmentY) {

            case SwingConstants.CENTER:

            case SwingConstants.TOP:

            case SwingConstants.BOTTOM:

                break;

            default:

                throw new IllegalArgumentException("Incorrent value '" + alignmentY + "' of AlignmentY.");

        }

        this.orientation = orientation;

        this.gap = gap;

        this.alignmentX = alignmentX;

        this.alignmentY = alignmentY;

        for (int i = 0; i < icons.length; i++) {

            if (icons[i] == null) {

                String message = "Icon (" + i + ") cannot be null";

                throw new IllegalArgumentException(message);

            }

        }

        this.icons = icons;

    }

    /**

     * Get the orientation along which each icon is painted.

     *

     * @return the orientation

     */

    @Override

    public int getOrientation() {

        return orientation;

    }

    /**

     * Get the gap between each icon

     *

     * @return the gap in pixels

     */

    @Override

    public int getGap() {

        return gap;

    }

    /**

     * Get the alignment of the icon on the x-axis

     *

     * @return the alignment

     */

    @Override

    public float getAlignmentX() {

        return alignmentX;

    }

    /**

     * Get the alignment of the icon on the y-axis

     *

     * @return the alignment

     */

    @Override

    public float getAlignmentY() {

        return alignmentY;

    }

    /**

     * Get the number of Icons contained in this CompoundIcon.

     *

     * @return the total number of Icons

     */

    @Override

    public int getIconCount() {

        return icons.length;

    }

    /**

     * Get the Icon at the specified index.

     *

     * @param index the index of the Icon to be returned

     * @return the Icon at the specifed index

     * @exception IndexOutOfBoundsException if the index is out of range

     */

    @Override

    public Icon getIcon(int index) {

        return icons[index];

    }

    /**

     * Gets the width of this icon.

     *

     * @return the width of the icon in pixels.

     */

    @Override

    public int getIconWidth() {

        int width = 0;

        //  Add the width of all Icons while also including the gap

        if (orientation == SwingConstants.HORIZONTAL) {

            width += (icons.length - 1) * gap;

            for (Icon icon : icons) {

                width += icon.getIconWidth();

            }

        } else { //  Just find the maximum width

            for (Icon icon : icons) {

                width = Math.max(width, icon.getIconWidth());

            }

        }

        return width;

    }

    /**

     * Gets the height of this icon.

     *

     * @return the height of the icon in pixels.

     */

    @Override

    public int getIconHeight() {

        int height = 0;

        //  Add the height of all Icons while also including the gap

        if (orientation == SwingConstants.VERTICAL) {

            height += (icons.length - 1) * gap;

            for (Icon icon : icons) {

                height += icon.getIconHeight();

            }

        } else { //  Just find the maximum height

            for (Icon icon : icons) {

                height = Math.max(height, icon.getIconHeight());

            }

        }

        return height;

    }

    /**

     * Paint the icons of this compound icon at the specified location

     *

     * @param c The component on which the icon is painted

     * @param g the graphics context

     * @param x the X coordinate of the icon's top-left corner

     * @param y the Y coordinate of the icon's top-left corner

     */

    @Override

    public void paintIcon(Component c, Graphics g, int x, int y) {

        switch (orientation) {

            default:

            case SwingConstants.HORIZONTAL:

                {

                    int height = getIconHeight();

                    for (Icon icon : icons) {

                        int iconY = getOffset(height, icon.getIconHeight(), alignmentY);

                        icon.paintIcon(c, g, x, y + iconY);

                        x += icon.getIconWidth() + gap;

                    }       break;

                }

            case SwingConstants.VERTICAL:

                {

                    int width = getIconWidth();

                    for (Icon icon : icons) {

                        int iconX = getOffset(width, icon.getIconWidth(), alignmentX);

                        icon.paintIcon(c, g, x + iconX, y);

                        y += icon.getIconHeight() + gap;

                    }       break;

                }

            case STACKED:

                {

                    int width = getIconWidth();

                    int height = getIconHeight();

                    for (Icon icon : icons) {

                        int iconX = getOffset(width, icon.getIconWidth(), alignmentX);

                        int iconY = getOffset(height, icon.getIconHeight(), alignmentY);

                        icon.paintIcon(c, g, x + iconX, y + iconY);

                    }       break;

                }

        }

    }

    /*

	 *  When the icon value is smaller than the maximum value of all icons the

	 *  icon needs to be aligned appropriately. Calculate the offset to be used

	 *  when painting the icon to achieve the proper alignment.

     */

    private int getOffset(int maxValue, int iconValue, int alignment) {

        float offset;

        switch (alignment) {

            case SwingConstants.TOP: