1 /*

     2  *

     3  * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions

     7  * are met:

     8  *

     9  *   - Redistributions of source code must retain the above copyright

    10  *     notice, this list of conditions and the following disclaimer.

    11  *

    12  *   - Redistributions in binary form must reproduce the above copyright

    13  *     notice, this list of conditions and the following disclaimer in the

    14  *     documentation and/or other materials provided with the distribution.

    15  *

    16  *   - Neither the name of Oracle nor the names of its

    17  *     contributors may be used to endorse or promote products derived

    18  *     from this software without specific prior written permission.

    19  *

    20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

    21  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

    22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    28  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    29  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    31  */

    32 

    33 

    34 package java2d;

    35 

    36 

    37 /**

    38  * Demos that animate extend this class.

    39  */

    40 @SuppressWarnings("serial")

    41 public abstract class AnimatingSurface extends Surface implements Runnable {

    42 

    43     private volatile boolean running = false;

    44 

    45     private volatile Thread thread;

    46 

    47     public abstract void step(int w, int h);

    48 

    49     public abstract void reset(int newwidth, int newheight);

    50 

    51 

    52     public synchronized void start() {

    53         if (!running() && !dontThread) {

    54             thread = new Thread(this);

    55             thread.setPriority(Thread.MIN_PRIORITY);

    56             thread.setName(name + " Demo");

    57             thread.start();

    58             running = true;

    59         }

    60     }

    61 

    62 

    63     public synchronized void stop() {

    64         if (thread != null) {

    65             running = false;

    66             thread.interrupt();

    67         }

    68         thread = null;

    69         notifyAll();

    70     }

    71 

    72 

    73     @Override

    74     @SuppressWarnings("SleepWhileHoldingLock")

    75     public void run() {

    76 

    77         while (running() && !isShowing() || getSize().width == 0) {

    78             try {

    79                 Thread.sleep(200);

    80             } catch (InterruptedException ignored) {

    81             }

    82         }

    83 

    84         while (running()) {

    85             repaint();

    86             try {

    87                 Thread.sleep(sleepAmount);

    88             } catch (InterruptedException ignored) {

    89             }

    90         }

    91         synchronized (this) {

    92             running = false;

    93         }

    94     }

    95 

    96     /**

    97      * @return the running

    98      */

    99     public synchronized boolean running() {

   100         return running;

   101     }

   102 

   103     /**

   104      * Causes surface to repaint immediately

   105      */

   106     public synchronized void doRepaint() {

   107         if (running() && thread != null) {

   108             thread.interrupt();

   109         }

   110     }

   111 }