scilab/modules/xcos/src/java/org/scilab/modules/xcos/palette/view/PaletteView.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2010 - DIGITEO - Clement DAVID
   4  * Copyright (C) 2011-2017 - Scilab Enterprises - Clement DAVID
   5  * Copyright (C) 2015 - Marcos CARDINOT
   6  *
   7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   8  *
   9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
  10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
  11  * This file was originally licensed under the terms of the CeCILL v2.1,
  12  * and continues to be available under such terms.
  13  * For more information, see the COPYING file which you should have received
  14  * along with this program.
  15  *
  16  */
  17
  18 package org.scilab.modules.xcos.palette.view;
  19
  20 import java.awt.AlphaComposite;
  21 import java.awt.Color;
  22 import java.awt.Dimension;
  23 import java.awt.FlowLayout;
  24 import java.awt.Graphics;
  25 import java.awt.Graphics2D;
  26 import java.awt.Rectangle;
  27 import java.awt.event.FocusEvent;
  28 import java.awt.event.FocusListener;
  29 import java.awt.geom.Rectangle2D;
  30
  31 import javax.swing.JPanel;
  32 import javax.swing.Scrollable;
  33 import javax.swing.SwingConstants;
  34
  35 import org.scilab.modules.xcos.utils.XcosConstants;
  36 import org.scilab.modules.xcos.utils.XcosConstants.PaletteBlockSize;
  37
  38 /**
  39  * Implement a view of a block category.
  40  *
  41  * As the JScrollPane doesn't allow a to specify it's associated layout, we have
  42  * to use a mainArea to perform what we want there. Never use the
  43  * {@link javax.swing.JScrollPane#add(java.awt.Component)} on this class but use
  44  * {@link JPanel#add(java.awt.Component)} instead.
  45  */
  46 @SuppressWarnings(value = { "serial" })
  47 public class PaletteView extends JPanel implements Scrollable {
  48
  49     private static Rectangle2D.Double selectionRect;
  50     private boolean isLoaded;
  51
  52     /**
  53      * Default constructor
  54      */
  55     public PaletteView() {
  56         setName("PaletteView");
  57         initComponents();
  58     }
  59
  60     /** Setup component */
  61     private void initComponents() {
  62         setBackground(Color.WHITE);
  63
  64         setLayout(new ModifiedFlowLayout(FlowLayout.LEADING,
  65                                          XcosConstants.PALETTE_HMARGIN,
  66                                          XcosConstants.PALETTE_VMARGIN));
  67
  68         // if this panel gains focus, try to select the first block!
  69         setFocusable(true);
  70         addFocusListener(new FocusListener() {
  71             @Override
  72             public void focusLost(FocusEvent e) {
  73             }
  74             @Override
  75             public void focusGained(FocusEvent e) {
  76                 try {
  77                     if (getComponentCount() > 0) {
  78                         ((PaletteBlockView) getComponent(0)).getController().setSelected(true);
  79                     }
  80                 } catch (ClassCastException err) {
  81                 } catch (NullPointerException err) {
  82                 }
  83             }
  84         });
  85     }
  86
  87     /**
  88      * Sets the selection rectangle
  89      * @param rect Rectangle2D
  90      */
  91     public void setSelectionRectangle(Rectangle2D.Double rect) {
  92         selectionRect = rect;
  93         this.repaint();
  94     }
  95
  96     /**
  97      * @return true if the view is already loaded
  98      */
  99     public boolean isLoaded() {
 100         return isLoaded;
 101     }
 102
 103     /**
 104      * This class update the status of the view. If you want to save memory,
 105      * unload the view when hidden.
 106      *
 107      * @param b
 108      *            the load status
 109      */
 110     public void setLoaded(boolean b) {
 111         if (!b) {
 112             removeAll();
 113         }
 114         isLoaded = b;
 115     }
 116
 117     /**
 118      * @return The prefered Scrollable dimension
 119      * @see javax.swing.Scrollable#getPreferredScrollableViewportSize()
 120      */
 121     @Override
 122     public Dimension getPreferredScrollableViewportSize() {
 123         return getPreferredSize();
 124     }
 125
 126     /**
 127      * @param visibleRect
 128      *            The view area visible within the viewport
 129      * @param orientation
 130      *            Either SwingConstants.VERTICAL or SwingConstants.HORIZONTAL.
 131      * @param direction
 132      *            Less than zero to scroll up/left, greater than zero for
 133      *            down/right.
 134      * @return The "block" increment for scrolling in the specified direction.
 135      *         This value should always be positive.
 136      * @see javax.swing.Scrollable#getScrollableBlockIncrement(java.awt.Rectangle,
 137      *      int, int)
 138      */
 139     @Override
 140     public int getScrollableBlockIncrement(Rectangle visibleRect,
 141                                            int orientation, int direction) {
 142         PaletteBlockSize palBlockSize = PaletteManagerPanel.getCurrentSize();
 143         if (orientation == SwingConstants.VERTICAL) {
 144             return palBlockSize.getBlockDimension().height
 145                    + XcosConstants.PALETTE_VMARGIN;
 146         } else {
 147             return palBlockSize.getBlockDimension().width
 148                    + XcosConstants.PALETTE_HMARGIN;
 149         }
 150     }
 151
 152     /**
 153      * @return always false
 154      * @see javax.swing.Scrollable#getScrollableTracksViewportHeight()
 155      */
 156     @Override
 157     public boolean getScrollableTracksViewportHeight() {
 158         return false;
 159     }
 160
 161     /**
 162      * @return always true
 163      * @see javax.swing.Scrollable#getScrollableTracksViewportWidth()
 164      */
 165     @Override
 166     public boolean getScrollableTracksViewportWidth() {
 167         return true;
 168     }
 169
 170     /**
 171      * @param visibleRect
 172      *            The view area visible within the viewport
 173      * @param orientation
 174      *            Either SwingConstants.VERTICAL or SwingConstants.HORIZONTAL.
 175      * @param direction
 176      *            Less than zero to scroll up/left, greater than zero for
 177      *            down/right.
 178      * @return PALETTE_BLOCK_HEIGHT or PALETTE_BLOCK_WIDTH depending on
 179      *         direction.
 180      * @see javax.swing.Scrollable#getScrollableUnitIncrement(java.awt.Rectangle,
 181      *      int, int)
 182      */
 183     @Override
 184     public int getScrollableUnitIncrement(Rectangle visibleRect,
 185                                           int orientation, int direction) {
 186         PaletteBlockSize palBlockSize = PaletteManagerPanel.getCurrentSize();
 187         if (orientation == SwingConstants.VERTICAL) {
 188             return palBlockSize.getBlockDimension().height;
 189         } else {
 190             return palBlockSize.getBlockDimension().width;
 191         }
 192     }
 193
 194     /**
 195      * Paints the selection rectangle.
 196      * @param g Graphics
 197      */
 198     @Override
 199     protected void paintComponent(Graphics g) {
 200         super.paintComponent(g);
 201         if (selectionRect == null) {
 202             return;
 203         }
 204
 205         Graphics2D g2d = (Graphics2D) g;
 206         final float alpha = 0.1f;
 207         AlphaComposite ta = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
 208         g2d.setComposite(ta);
 209         g2d.setColor(Color.BLUE);
 210         g2d.fill(selectionRect);
 211         g2d.setComposite(AlphaComposite.SrcOver);
 212         g2d.setColor(Color.BLACK);
 213         g2d.draw(selectionRect);
 214     }
 215 }