package fr.ifremer.quadrige3.ui.swing.plaf;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 UI Common
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 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 Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import org.jdesktop.jxlayer.JXLayer;
  import org.jdesktop.jxlayer.plaf.AbstractLayerUI;
  
  import javax.swing.JComponent;
  import javax.swing.Timer;
  import java.awt.*;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.MouseEvent;
  
  /**
   * A JXLayer ui implementation that permits to block a component
   *
   * @author Ludovic - ludovic.pecquot@e-is.pro
   */
  public class ComponentBlockingLayerUI extends AbstractLayerUI<JComponent> implements ActionListener {
  
      /** Constant <code>BLOCK_PROPERTY="block"</code> */
      public static final String BLOCK_PROPERTY = "block";
  
      /**
       * Optional color to put fill background when blocking
       */
      private Color blockingColor = Color.BLACK;
  
      /**
       * Internal state when should block event and paint layer
       */
      private boolean block;
      boolean running;
      boolean started;
      private boolean fadingOut;
  
      private Timer timer;
      private float fadeCount;
      /** Constant <code>FPS=24</code> */
      private static final int FPS = 24;
      /** Constant <code>FADE_LIMIT=5f</code> */
      private static final float FADE_LIMIT = 5f;
      /** Constant <code>DELAY=100</code> */
      private static final int DELAY = 100;
  
      /**
       * <p>Constructor for ComponentBlockingLayerUI.</p>
       */
      public ComponentBlockingLayerUI() {
      }
  
      /**
       * <p>Setter for the field <code>block</code>.</p>
       *
       * @param block a boolean.
       */
      public void setBlock(boolean block) {
          boolean oldValue = this.block;
          this.block = block;
          firePropertyChange(BLOCK_PROPERTY, oldValue, block);
          if (oldValue != block) {
              setDirty(true);
              if (block) {
                  start();
              } else {
                  stop();
              }
          }
      }
  
      /**
       * <p>Setter for the field <code>blockingColor</code>.</p>
       *
       * @param blockingColor a {@link Color} object.
       */
      public void setBlockingColor(Color blockingColor) {
          this.blockingColor = blockingColor;
     }
 
     /** {@inheritDoc} */
     @Override
     protected void paintLayer(Graphics2D g2, JXLayer<? extends JComponent> l) {
         super.paintLayer(g2, l);
         if (!running || !started) {
             return;
         }
 
         // Gray it out.
         Composite urComposite = g2.getComposite();
         g2.setColor(blockingColor);
         float alpha = .25f * getFade();
         g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
         g2.fillRect(0, 0, l.getWidth(), l.getHeight());
         g2.setComposite(urComposite);
 
     }
 
     protected float getFade() {
         return fadeCount / FADE_LIMIT;
     }
 
     /** {@inheritDoc} */
     @Override
     public void actionPerformed(ActionEvent e) {
         if (running) {
             started = true;
             setDirty(true);
             if (fadingOut) {
                 if (--fadeCount <= 0) {
                     running = false;
                     started = false;
                     timer.stop();
                 }
             } else if (fadeCount < FADE_LIMIT) {
                 fadeCount++;
             }
         }
     }
 
     /**
      * <p>start.</p>
      */
     public void start() {
         if (running) {
             return;
         }
 
         // Run a thread for animation.
         running = true;
         started = false;
         fadingOut = false;
         fadeCount = 0;
         int tick = FPS / 1000;
         timer = new Timer(tick, this);
         timer.setInitialDelay(DELAY);
         timer.start();
     }
 
     /**
      * <p>stop.</p>
      */
     public void stop() {
         if (started) {
             fadingOut = true;
         } else {
             running = false;
             timer.stop();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     protected void processMouseEvent(MouseEvent e, JXLayer<? extends JComponent> l) {
         if (running) {
             e.consume();
             return;
         }
         super.processMouseEvent(e, l);
     }
 }