bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/g2d/events/EventTypes.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2011 Association for Decentralized Information Management in
   3  * Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.scenegraph.g2d.events;
  13
  14 import java.util.concurrent.ConcurrentHashMap;
  15 import java.util.concurrent.ConcurrentMap;
  16
  17 import org.simantics.scenegraph.g2d.events.FocusEvent.FocusGainedEvent;
  18 import org.simantics.scenegraph.g2d.events.FocusEvent.FocusLostEvent;
  19 import org.simantics.scenegraph.g2d.events.KeyEvent.KeyPressedEvent;
  20 import org.simantics.scenegraph.g2d.events.KeyEvent.KeyReleasedEvent;
  21 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonPressedEvent;
  22 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonReleasedEvent;
  23 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseClickEvent;
  24 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseDoubleClickedEvent;
  25 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseEnterEvent;
  26 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseExitEvent;
  27 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseMovedEvent;
  28 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseWheelMovedEvent;
  29 import org.simantics.scenegraph.g2d.events.command.CommandEvent;
  30
  31 /**
  32  * Event type masks are used for specifying the kinds of events an
  33  * {@link IEventHandler} wishes to receive.
  34  *
  35  * @author Tuukka Lehtonen
  36  */
  37 public final class EventTypes {
  38
  39     /**
  40      * @see CommandEvent
  41      */
  42     public static final int Command                 = 1;
  43     public static final int CommandMask             = toMask(Command);
  44
  45     /**
  46      * @see FocusGainedEvent
  47      */
  48     public static final int FocusGained             = 2;
  49     public static final int FocusGainedMask         = toMask(FocusGained);
  50
  51     /**
  52      * @see FocusLostEvent
  53      */
  54     public static final int FocusLost               = 3;
  55     public static final int FocusLostMask           = toMask(FocusLost);
  56
  57     /**
  58      * One of: {@link #FocusGained}, {@link #FocusLost}.
  59      */
  60     public static final int FocusMask               = FocusGainedMask | FocusLostMask;
  61
  62     /**
  63      * @see KeyPressedEvent
  64      */
  65     public static final int KeyPressed              = 4;
  66     public static final int KeyPressedMask          = toMask(KeyPressed);
  67
  68     /**
  69      * @see KeyReleasedEvent
  70      */
  71     public static final int KeyReleased             = 5;
  72     public static final int KeyReleasedMask         = toMask(KeyReleased);
  73
  74     /**
  75      * One of: {@link #KeyPressed}, {@link #KeyReleased}
  76      */
  77     public static final int KeyMask                 = KeyPressedMask | KeyReleasedMask;
  78
  79     /**
  80      * @see MouseButtonPressedEvent
  81      */
  82     public static final int MouseButtonPressed      = 6;
  83     public static final int MouseButtonPressedMask  = toMask(MouseButtonPressed);
  84
  85     /**
  86      * @see MouseButtonReleasedEvent
  87      */
  88     public static final int MouseButtonReleased     = 7;
  89     public static final int MouseButtonReleasedMask = toMask(MouseButtonReleased);
  90
  91     /**
  92      * @see MouseClickEvent
  93      */
  94     public static final int MouseClick              = 8;
  95     public static final int MouseClickMask          = toMask(MouseClick);
  96
  97     /**
  98      * @see MouseDoubleClickedEvent
  99      */
 100     public static final int MouseDoubleClick        = 9;
 101     public static final int MouseDoubleClickMask    = toMask(MouseDoubleClick);
 102
 103     /**
 104      * @see org.simantics.scenegraph.g2d.events.MouseEvent.MouseDragBegin
 105      */
 106     public static final int MouseDragBegin          = 10;
 107     public static final int MouseDragBeginMask      = toMask(MouseDragBegin);
 108
 109     /**
 110      * One of: {@link #MouseButtonPressed}, {@link #MouseButtonReleased},
 111      * {@link #MouseClick}, {@link #MouseDoubleClick}, {@link #MouseDragBegin}
 112      */
 113     public static final int MouseButtonMask         = MouseButtonPressedMask | MouseButtonReleasedMask | MouseClickMask
 114                                                       | MouseDoubleClickMask | MouseDragBeginMask;
 115
 116     /**
 117      * @see MouseEnterEvent
 118      */
 119     public static final int MouseEnter              = 11;
 120     public static final int MouseEnterMask          = toMask(MouseEnter);
 121
 122     /**
 123      * @see MouseExitEvent
 124      */
 125     public static final int MouseExit               = 12;
 126     public static final int MouseExitMask           = toMask(MouseExit);
 127
 128     /**
 129      * @see MouseMovedEvent
 130      */
 131     public static final int MouseMoved              = 13;
 132     public static final int MouseMovedMask          = toMask(MouseMoved);
 133
 134     public static final int MouseMoveMask           = MouseEnterMask | MouseExitMask | MouseMovedMask;
 135
 136     /**
 137      * @see MouseWheelMovedEvent
 138      */
 139     public static final int MouseWheel              = 14;
 140     public static final int MouseWheelMask          = toMask(MouseWheel);
 141
 142     /**
 143      * One of: {@link #MouseButton}, {@link #MouseMove}, {@link #MouseWheel}
 144      */
 145     public static final int MouseMask               = MouseButtonMask | MouseMoveMask | MouseWheelMask;
 146
 147     /**
 148      * @see TimeEvent
 149      */
 150     public static final int Time                    = 15;
 151     public static final int TimeMask                = toMask(Time);
 152
 153     /**
 154      * One of: {@link #Command}, {@link #Focus}, {@link #Key}, {@link #Mouse},
 155      * {@link #Time}
 156      */
 157     public static final int AnyMask                 = CommandMask | FocusMask | KeyMask | MouseMask | TimeMask;
 158
 159     /**
 160      * For testing whether the specified event mask passes the specified event.
 161      *
 162      * @param eventMask
 163      * @param event
 164      * @return
 165      */
 166     public static boolean passes(IEventHandler handler, Event event) {
 167         int mask = handler.getEventMask();
 168         return passes(mask, event);
 169     }
 170
 171     /**
 172      * For testing whether the specified event mask passes the specified event.
 173      *
 174      * @param mask
 175      * @param event
 176      * @return
 177      */
 178     public static boolean passes(int mask, Event event) {
 179         int et = toTypeMask(event);
 180         return (et & mask) != 0;
 181     }
 182
 183     /**
 184      * For testing whether the specified event mask passes the specified event.
 185      *
 186      * @param eventMask
 187      * @param event
 188      * @return
 189      */
 190     public static boolean passes(IEventHandler handler, int eventTypeMask) {
 191         return (eventTypeMask & handler.getEventMask()) != 0;
 192     }
 193
 194     /**
 195      * For testing whether the specified event type passes the specified event mask.
 196      *
 197      * @param mask
 198      * @param event
 199      * @return
 200      */
 201     public static boolean passes(int mask, int eventTypeMask) {
 202         return (eventTypeMask & mask) != 0;
 203     }
 204
 205     /**
 206      * Converts the specified event instance to an event type mask representing the event.
 207      *
 208      * @param event
 209      * @return
 210      */
 211     public static int toTypeMask(Event event) {
 212         return event != null ? toTypeMask(event.getClass()) : 0;
 213     }
 214
 215     /**
 216      * Converts the specified event instance to an integer describing the event.
 217      *
 218      * @param event
 219      * @return
 220      */
 221     public static int toType(Event event) {
 222         return event != null ? toType(event.getClass()) : 0;
 223     }
 224
 225     /**
 226      * Converts the specified event class to an event type mask representing the event.
 227      *
 228      * @param event
 229      * @return
 230      */
 231     public static int toTypeMask(Class<? extends Event> clazz) {
 232         if (clazz == null)
 233             return 0;
 234         Integer type = maskCache.get(clazz);
 235         if (type != null)
 236             return type;
 237         type = calculateTypeMask(clazz);
 238         maskCache.putIfAbsent(clazz, type);
 239         return type;
 240     }
 241
 242     /**
 243      * Converts the specified event class to an integer representing that specific event type.
 244      *
 245      * @param event
 246      * @return
 247      */
 248     public static int toType(Class<? extends Event> clazz) {
 249         if (clazz == null)
 250             return 0;
 251         Integer type = typeCache.get(clazz);
 252         if (type != null)
 253             return type;
 254         type = calculateType(clazz);
 255         typeCache.putIfAbsent(clazz, type);
 256         return type;
 257     }
 258
 259     /**
 260      * Converts the specified event instance to an event type mask representing
 261      * the event.
 262      *
 263      * @param clazz class of event to get type for
 264      * @return event type mask
 265      * @throws IllegalArgumentException if event class is not recognized
 266      */
 267     private static int calculateTypeMask(Class<? extends Event> clazz) {
 268         if (Event.class.isAssignableFrom(clazz)) {
 269             if (MouseEvent.class.isAssignableFrom(clazz)) {
 270                 if (MouseMovedEvent.class.isAssignableFrom(clazz))
 271                     return MouseMovedMask;
 272                 if (MouseButtonPressedEvent.class.isAssignableFrom(clazz))
 273                     return MouseButtonPressedMask;
 274                 if (MouseButtonReleasedEvent.class.isAssignableFrom(clazz))
 275                     return MouseButtonReleasedMask;
 276                 if (MouseClickEvent.class.isAssignableFrom(clazz))
 277                     return MouseClickMask;
 278                 if (MouseWheelMovedEvent.class.isAssignableFrom(clazz))
 279                     return MouseWheelMask;
 280                 if (MouseDoubleClickedEvent.class.isAssignableFrom(clazz))
 281                     return MouseDoubleClickMask;
 282                 if (org.simantics.scenegraph.g2d.events.MouseEvent.MouseDragBegin.class.isAssignableFrom(clazz))
 283                     return MouseDragBeginMask;
 284                 if (MouseEnterEvent.class.isAssignableFrom(clazz))
 285                     return MouseEnterMask;
 286                 if (MouseExitEvent.class.isAssignableFrom(clazz))
 287                     return MouseExitMask;
 288                 return MouseMask;
 289             }
 290
 291             if (KeyEvent.class.isAssignableFrom(clazz)) {
 292                 if (KeyPressedEvent.class.isAssignableFrom(clazz))
 293                     return KeyPressedMask;
 294                 if (KeyReleasedEvent.class.isAssignableFrom(clazz))
 295                     return KeyReleasedMask;
 296                 return KeyMask;
 297             }
 298
 299             if (FocusEvent.class.isAssignableFrom(clazz)) {
 300                 if (FocusGainedEvent.class.isAssignableFrom(clazz))
 301                     return FocusGainedMask;
 302                 if (FocusLostEvent.class.isAssignableFrom(clazz))
 303                     return FocusLostMask;
 304                 return FocusMask;
 305             }
 306
 307             if (CommandEvent.class.isAssignableFrom(clazz))
 308                 return CommandMask;
 309
 310             if (TimeEvent.class.isAssignableFrom(clazz))
 311                 return TimeMask;
 312
 313             return AnyMask;
 314         }
 315         throw new IllegalArgumentException("unrecognized event class: " + clazz);
 316     }
 317
 318
 319     /**
 320      * Converts the specified event instance to an event type mask representing
 321      * the event.
 322      *
 323      * @param clazz class of event to get type for
 324      * @return event type mask
 325      * @throws IllegalArgumentException if event class is not recognized
 326      */
 327     private static int calculateType(Class<? extends Event> clazz) {
 328         if (Event.class.isAssignableFrom(clazz)) {
 329             if (MouseEvent.class.isAssignableFrom(clazz)) {
 330                 if (MouseMovedEvent.class.isAssignableFrom(clazz))
 331                     return MouseMoved;
 332                 if (MouseButtonPressedEvent.class.isAssignableFrom(clazz))
 333                     return MouseButtonPressed;
 334                 if (MouseButtonReleasedEvent.class.isAssignableFrom(clazz))
 335                     return MouseButtonReleased;
 336                 if (MouseClickEvent.class.isAssignableFrom(clazz))
 337                     return MouseClick;
 338                 if (MouseWheelMovedEvent.class.isAssignableFrom(clazz))
 339                     return MouseWheel;
 340                 if (MouseDoubleClickedEvent.class.isAssignableFrom(clazz))
 341                     return MouseDoubleClick;
 342                 if (org.simantics.scenegraph.g2d.events.MouseEvent.MouseDragBegin.class.isAssignableFrom(clazz))
 343                     return MouseDragBegin;
 344                 if (MouseEnterEvent.class.isAssignableFrom(clazz))
 345                     return MouseEnter;
 346                 if (MouseExitEvent.class.isAssignableFrom(clazz))
 347                     return MouseExit;
 348             }
 349
 350             if (KeyEvent.class.isAssignableFrom(clazz)) {
 351                 if (KeyPressedEvent.class.isAssignableFrom(clazz))
 352                     return KeyPressed;
 353                 if (KeyReleasedEvent.class.isAssignableFrom(clazz))
 354                     return KeyReleased;
 355             }
 356
 357             if (FocusEvent.class.isAssignableFrom(clazz)) {
 358                 if (FocusGainedEvent.class.isAssignableFrom(clazz))
 359                     return FocusGained;
 360                 if (FocusLostEvent.class.isAssignableFrom(clazz))
 361                     return FocusLost;
 362             }
 363
 364             if (CommandEvent.class.isAssignableFrom(clazz))
 365                 return Command;
 366
 367             if (TimeEvent.class.isAssignableFrom(clazz))
 368                 return Time;
 369         }
 370         throw new IllegalArgumentException("unrecognized event class: " + clazz);
 371     }
 372
 373     private static ConcurrentMap<Class<?>, Integer> maskCache = new ConcurrentHashMap<Class<?>, Integer>();
 374     private static ConcurrentMap<Class<?>, Integer> typeCache = new ConcurrentHashMap<Class<?>, Integer>();
 375
 376     private static int toMask(int eventType) {
 377         return (1 << eventType);
 378     }
 379
 380 }