bundles/org.simantics.g2d/src/org/simantics/g2d/participant/TimeParticipant.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.g2d.participant;\r
  13 \r
  14 import java.util.HashSet;\r
  15 import java.util.Set;\r
  16 import java.util.concurrent.ScheduledFuture;\r
  17 import java.util.concurrent.TimeUnit;\r
  18 \r
  19 import org.simantics.g2d.canvas.ICanvasContext;\r
  20 import org.simantics.g2d.canvas.impl.AbstractCanvasParticipant;\r
  21 import org.simantics.g2d.diagram.participant.ElementHeartbeater;\r
  22 import org.simantics.g2d.element.handler.Heartbeat;\r
  23 import org.simantics.scenegraph.g2d.events.Event;\r
  24 import org.simantics.scenegraph.g2d.events.TimeEvent;\r
  25 import org.simantics.scenegraph.g2d.events.EventHandlerReflection.EventHandler;\r
  26 import org.simantics.utils.datastructures.disposable.DisposeState;\r
  27 import org.simantics.utils.datastructures.hints.HintListenerAdapter;\r
  28 import org.simantics.utils.datastructures.hints.IHintListener;\r
  29 import org.simantics.utils.datastructures.hints.IHintObservable;\r
  30 import org.simantics.utils.datastructures.hints.IHintContext.Key;\r
  31 import org.simantics.utils.datastructures.hints.IHintContext.KeyOf;\r
  32 import org.simantics.utils.threads.ThreadUtils;\r
  33 \r
  34 /**\r
  35  * Time Participant sends time pulses by setting KEY_TIME hint. The value of\r
  36  * KEY_TIME is system current time in milliseconds.\r
  37  * \r
  38  * The hint KEY_TIME_PULSE_INTERVAL controls the interval of time pulse events.\r
  39  * \r
  40  * Time pulse events can be listened by listening modifications of KEY_TIME\r
  41  * hint.\r
  42  * \r
  43  * KEY_TIMER_ENABLED controls the enabled state of the timer, if false, no\r
  44  * events will be sent even if there are recipients.\r
  45  * \r
  46  * To be able receive timer events, add a handler like this to your canvas\r
  47  * participant:<pre>\r
  48  * &#064;EventHandler(priority = 0)\r
  49  * public boolean handleTimeEvent(TimeEvent e) {\r
  50  *     // do something\r
  51  *     // Don't eat the event, let others see it too.\r
  52  *     return false;\r
  53  * }</pre>\r
  54  * When you need to receive time events, inform TimeParticipant by invoking\r
  55  * <code>timeParticipant.registerForEvents(getClass());</code> and when you no\r
  56  * longer need the events, use\r
  57  * <code>timeParticipant.unregisterForEvents(getClass());</code>. This allows\r
  58  * TimeParticipant to optimize its internal behavior.\r
  59  *\r
  60  * @author Toni Kalajainen\r
  61  * @author Tuukka Lehtonen\r
  62  *\r
  63  * @see ElementHeartbeater\r
  64  * @see Heartbeat\r
  65  * @see Notifications\r
  66  */\r
  67 public class TimeParticipant extends AbstractCanvasParticipant {\r
  68 \r
  69     /** Key for global timer enable state */\r
  70     public static final Key KEY_TIMER_ENABLED = new KeyOf(Boolean.class);\r
  71 \r
  72     /** Key for time code */\r
  73     public static final Key KEY_TIME = new KeyOf(Long.class);\r
  74 \r
  75     /** Key for timer interval in milliseconds */\r
  76     public static final Key KEY_TIME_PULSE_INTERVAL = new KeyOf(Long.class);\r
  77 \r
  78     /** Default interval in milliseconds */\r
  79     public static final long DEFAULT_INTERVAL = 100L;\r
  80 \r
  81     ScheduledFuture<?> future = null;\r
  82 \r
  83     Set<Class<?>> eventRecipients = new HashSet<Class<?>>();\r
  84 \r
  85     IHintListener hintChangeListener = new HintListenerAdapter() {\r
  86         @Override\r
  87         public void hintChanged(IHintObservable sender, Key key, Object oldValue, Object newValue) {\r
  88             if (key == KEY_TIME_PULSE_INTERVAL || key == KEY_TIMER_ENABLED) {\r
  89                 updateInterval();\r
  90             }\r
  91         }\r
  92     };\r
  93 \r
  94     public void registerForEvents(Class<?> clazz) {\r
  95         boolean isEmpty = eventRecipients.isEmpty();\r
  96         boolean added = eventRecipients.add(clazz);\r
  97         if (isEmpty && added)\r
  98             // We've got a recipient, start sending timer events.\r
  99             updateInterval();\r
 100     }\r
 101 \r
 102     public void unregisterForEvents(Class<?> clazz) {\r
 103         eventRecipients.remove(clazz);\r
 104         if (eventRecipients.isEmpty()) {\r
 105             // No more event recipients, stop sending timer events.\r
 106             cancelTimer();\r
 107         }\r
 108     }\r
 109 \r
 110     private boolean hasRecipients() {\r
 111         return !eventRecipients.isEmpty();\r
 112     }\r
 113 \r
 114     public boolean isTimerEnabled() {\r
 115         return getHint(KEY_TIMER_ENABLED);\r
 116     }\r
 117 \r
 118     public void setTimerEnabled(boolean enabled) {\r
 119         setHint(KEY_TIMER_ENABLED, Boolean.valueOf(enabled));\r
 120     }\r
 121 \r
 122     public long getInterval()\r
 123     {\r
 124         Long interval = getHint(KEY_TIME_PULSE_INTERVAL);\r
 125         if (interval == null)\r
 126             return DEFAULT_INTERVAL;\r
 127         return interval;\r
 128     }\r
 129 \r
 130     public void setInterval(long interval)\r
 131     {\r
 132         setHint(KEY_TIME_PULSE_INTERVAL, interval);\r
 133     }\r
 134 \r
 135     @Override\r
 136     public void addedToContext(ICanvasContext ctx) {\r
 137         super.addedToContext(ctx);\r
 138 \r
 139         setHint(KEY_TIMER_ENABLED, Boolean.FALSE);\r
 140         setHint(KEY_TIME_PULSE_INTERVAL, DEFAULT_INTERVAL);\r
 141         ctx.getHintStack().addKeyHintListener(getContext().getThreadAccess(), KEY_TIME_PULSE_INTERVAL, hintChangeListener);\r
 142         ctx.getHintStack().addKeyHintListener(getContext().getThreadAccess(), KEY_TIMER_ENABLED, hintChangeListener);\r
 143         updateInterval();\r
 144     }\r
 145 \r
 146     @Override\r
 147     public void removedFromContext(ICanvasContext ctx) {\r
 148         ctx.getHintStack().removeKeyHintListener(getContext().getThreadAccess(), KEY_TIMER_ENABLED, hintChangeListener);\r
 149         ctx.getHintStack().removeKeyHintListener(getContext().getThreadAccess(), KEY_TIME_PULSE_INTERVAL, hintChangeListener);\r
 150         cancelTimer();\r
 151 \r
 152         eventRecipients.clear();\r
 153 \r
 154         super.removedFromContext(ctx);\r
 155     }\r
 156 \r
 157     private boolean commandInQueue = false;\r
 158 \r
 159     @EventHandler(priority = Integer.MAX_VALUE)\r
 160     public boolean handleTimeEvent(TimeEvent e) {\r
 161         commandInQueue = false;\r
 162         return false;\r
 163     }\r
 164 \r
 165     private long prevTime = System.currentTimeMillis();\r
 166 \r
 167     private final Runnable onEvent = new Runnable() {\r
 168         @Override\r
 169         public void run() {\r
 170             if (isRemoved() || !hasRecipients() || !isTimerEnabled()) {\r
 171                 cancelTimer();\r
 172                 return;\r
 173             }\r
 174 \r
 175             if (commandInQueue) return;\r
 176             ICanvasContext ctx = getContext();\r
 177             if (ctx==null || ctx.getDisposeState()!=DisposeState.Alive) return;\r
 178             long pTime = prevTime;\r
 179             Long time = System.currentTimeMillis();\r
 180             long interval = time - pTime;\r
 181             prevTime = time;\r
 182             setHint(KEY_TIME, time);\r
 183             Event e = new TimeEvent(getContext(), pTime, interval);\r
 184             commandInQueue = true;\r
 185             //System.out.println("sending time event: " + e);\r
 186             getContext().getEventQueue().queueFirst(e);\r
 187         }\r
 188     };\r
 189 \r
 190     Runnable onTimer = new Runnable() {\r
 191         @Override\r
 192         public void run() {\r
 193             // On time pulse\r
 194             asyncExec(onEvent);\r
 195         }\r
 196     };\r
 197 \r
 198     private void updateInterval()\r
 199     {\r
 200         // cancel old timer\r
 201         cancelTimer();\r
 202         if (isRemoved())\r
 203             return;\r
 204 \r
 205         boolean timerEnabled = isTimerEnabled();\r
 206         if (!timerEnabled)\r
 207             return;\r
 208 \r
 209         long interval = getInterval();\r
 210         future = ThreadUtils.getNonBlockingWorkExecutor().scheduleAtFixedRate(onTimer, DEFAULT_INTERVAL, interval, TimeUnit.MILLISECONDS);\r
 211     }\r
 212 \r
 213     private void cancelTimer() {\r
 214         if (future != null) {\r
 215             future.cancel(false);\r
 216             future = null;\r
 217         }\r
 218     }\r
 219 \r
 220 }\r