bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/widgets/TypedListener.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2016 IBM Corporation and others.
   3  *
   4  * This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License 2.0
   6  * which accompanies this distribution, and is available at
   7  * https://www.eclipse.org/legal/epl-2.0/
   8  *
   9  * SPDX-License-Identifier: EPL-2.0
  10  *
  11  * Contributors:
  12  *     IBM Corporation - initial API and implementation
  13  *******************************************************************************/
  14 package org.eclipse.swt.widgets;
  15
  16
  17 import org.eclipse.swt.internal.SWTEventListener;
  18 import org.eclipse.swt.*;
  19 import org.eclipse.swt.events.*;
  20
  21 /**
  22  * Instances of this class are <em>internal SWT implementation</em>
  23  * objects which provide a mapping between the typed and untyped
  24  * listener mechanisms that SWT supports.
  25  * <p>
  26  * <b>IMPORTANT:</b> This class is <em>not</em> part of the SWT
  27  * public API. It is marked public only so that it can be shared
  28  * within the packages provided by SWT. It should never be
  29  * referenced from application code.
  30  * </p>
  31  *
  32  * @see Listener
  33  * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
  34  */
  35 public class TypedListener implements Listener {
  36
  37         /**
  38          * The receiver's event listener
  39          */
  40         protected SWTEventListener eventListener;
  41
  42 /**
  43  * Constructs a new instance of this class for the given event listener.
  44  * <p>
  45  * <b>IMPORTANT:</b> This method is <em>not</em> part of the SWT
  46  * public API. It is marked public only so that it can be shared
  47  * within the packages provided by SWT. It should never be
  48  * referenced from application code.
  49  * </p>
  50  *
  51  * @param listener the event listener to store in the receiver
  52  *
  53  * @noreference This method is not intended to be referenced by clients.
  54  */
  55 public TypedListener (SWTEventListener listener) {
  56         eventListener = listener;
  57 }
  58
  59 /**
  60  * Returns the receiver's event listener.
  61  * <p>
  62  * <b>IMPORTANT:</b> This method is <em>not</em> part of the SWT
  63  * public API. It is marked public only so that it can be shared
  64  * within the packages provided by SWT. It should never be
  65  * referenced from application code.
  66  * </p>
  67  *
  68  * @return the receiver's event listener
  69  *
  70  * @noreference This method is not intended to be referenced by clients.
  71  */
  72 public SWTEventListener getEventListener () {
  73         return eventListener;
  74 }
  75
  76 /**
  77  * Handles the given event.
  78  * <p>
  79  * <b>IMPORTANT:</b> This method is <em>not</em> part of the SWT
  80  * public API. It is marked public only so that it can be shared
  81  * within the packages provided by SWT. It should never be
  82  * referenced from application code.
  83  * </p>
  84  * @param e the event to handle
  85  *
  86  * @noreference This method is not intended to be referenced by clients.
  87  */
  88 @Override
  89 public void handleEvent (Event e) {
  90         switch (e.type) {
  91                 case SWT.Activate: {
  92                         ((ShellListener) eventListener).shellActivated(new ShellEvent(e));
  93                         break;
  94                 }
  95                 case SWT.Arm: {
  96                         ((ArmListener) eventListener).widgetArmed (new ArmEvent (e));
  97                         break;
  98                 }
  99                 case SWT.Close: {
 100                         /* Fields set by Decorations */
 101                         ShellEvent event = new ShellEvent (e);
 102                         ((ShellListener) eventListener).shellClosed(event);
 103                         e.doit = event.doit;
 104                         break;
 105                 }
 106                 case SWT.Collapse: {
 107                         if (eventListener instanceof TreeListener) {
 108                                 ((TreeListener) eventListener).treeCollapsed(new TreeEvent(e));
 109                         } else {
 110                                 ((ExpandListener) eventListener).itemCollapsed(new ExpandEvent(e));
 111                         }
 112                         break;
 113                 }
 114                 case SWT.Deactivate: {
 115                         ((ShellListener) eventListener).shellDeactivated(new ShellEvent(e));
 116                         break;
 117                 }
 118                 case SWT.Deiconify: {
 119                         ((ShellListener) eventListener).shellDeiconified(new ShellEvent(e));
 120                         break;
 121                 }
 122                 case SWT.DefaultSelection: {
 123                         ((SelectionListener)eventListener).widgetDefaultSelected(new SelectionEvent(e));
 124                         break;
 125                 }
 126                 case SWT.Dispose: {
 127                         ((DisposeListener) eventListener).widgetDisposed(new DisposeEvent(e));
 128                         break;
 129                 }
 130                 case SWT.DragDetect: {
 131                         ((DragDetectListener) eventListener).dragDetected(new DragDetectEvent(e));
 132                         break;
 133                 }
 134                 case SWT.Expand: {
 135                         if (eventListener instanceof TreeListener) {
 136                                 ((TreeListener) eventListener).treeExpanded(new TreeEvent(e));
 137                         } else {
 138                                 ((ExpandListener) eventListener).itemExpanded(new ExpandEvent(e));
 139                         }
 140                         break;
 141                 }
 142                 case SWT.FocusIn: {
 143                         ((FocusListener) eventListener).focusGained(new FocusEvent(e));
 144                         break;
 145                 }
 146                 case SWT.FocusOut: {
 147                         ((FocusListener) eventListener).focusLost(new FocusEvent(e));
 148                         break;
 149                 }
 150                 case SWT.Gesture: {
 151                         GestureEvent event = new GestureEvent(e);
 152                         ((GestureListener)eventListener).gesture(event);
 153                         e.doit = event.doit;
 154                         break;
 155                 }
 156                 case SWT.Help: {
 157                         ((HelpListener) eventListener).helpRequested (new HelpEvent (e));
 158                         break;
 159                 }
 160                 case SWT.Hide: {
 161                         ((MenuListener) eventListener).menuHidden(new MenuEvent(e));
 162                         break;
 163                 }
 164                 case SWT.Iconify: {
 165                         ((ShellListener) eventListener).shellIconified(new ShellEvent(e));
 166                         break;
 167                 }
 168                 case SWT.KeyDown: {
 169                         /* Fields set by Control */
 170                         KeyEvent event = new KeyEvent(e);
 171                         ((KeyListener) eventListener).keyPressed(event);
 172                         e.doit = event.doit;
 173                         break;
 174                 }
 175                 case SWT.KeyUp: {
 176                         /* Fields set by Control */
 177                         KeyEvent event = new KeyEvent(e);
 178                         ((KeyListener) eventListener).keyReleased(event);
 179                         e.doit = event.doit;
 180                         break;
 181                 }
 182                 case SWT.Modify: {
 183                         ((ModifyListener) eventListener).modifyText(new ModifyEvent(e));
 184                         break;
 185                 }
 186                 case SWT.MenuDetect: {
 187                         MenuDetectEvent event = new MenuDetectEvent(e);
 188                         ((MenuDetectListener) eventListener).menuDetected(event);
 189                         e.x = event.x;
 190                         e.y = event.y;
 191                         e.doit = event.doit;
 192                         e.detail = event.detail;
 193                         break;
 194                 }
 195                 case SWT.MouseDown: {
 196                         ((MouseListener) eventListener).mouseDown(new MouseEvent(e));
 197                         break;
 198                 }
 199                 case SWT.MouseDoubleClick: {
 200                         ((MouseListener) eventListener).mouseDoubleClick(new MouseEvent(e));
 201                         break;
 202                 }
 203                 case SWT.MouseEnter: {
 204                         ((MouseTrackListener) eventListener).mouseEnter (new MouseEvent (e));
 205                         break;
 206                 }
 207                 case SWT.MouseExit: {
 208                         ((MouseTrackListener) eventListener).mouseExit (new MouseEvent (e));
 209                         break;
 210                 }
 211                 case SWT.MouseHover: {
 212                         ((MouseTrackListener) eventListener).mouseHover (new MouseEvent (e));
 213                         break;
 214                 }
 215                 case SWT.MouseMove: {
 216                         ((MouseMoveListener) eventListener).mouseMove(new MouseEvent(e));
 217                         return;
 218                 }
 219                 case SWT.MouseWheel: {
 220                         ((MouseWheelListener) eventListener).mouseScrolled(new MouseEvent(e));
 221                         return;
 222                 }
 223                 case SWT.MouseUp: {
 224                         ((MouseListener) eventListener).mouseUp(new MouseEvent(e));
 225                         break;
 226                 }
 227                 case SWT.Move: {
 228                         ((ControlListener) eventListener).controlMoved(new ControlEvent(e));
 229                         break;
 230                 }
 231                 case SWT.Paint: {
 232                         /* Fields set by Control */
 233                         PaintEvent event = new PaintEvent (e);
 234                         ((PaintListener) eventListener).paintControl (event);
 235                         e.gc = event.gc;
 236                         break;
 237                 }
 238                 case SWT.Resize: {
 239                         ((ControlListener) eventListener).controlResized(new ControlEvent(e));
 240                         break;
 241                 }
 242                 case SWT.Segments: {
 243                         SegmentEvent event = new SegmentEvent(e);
 244                         ((SegmentListener) eventListener).getSegments(event);
 245                         e.segments = event.segments;
 246                         e.segmentsChars = event.segmentsChars;
 247                         break;
 248                 }
 249                 case SWT.Selection: {
 250                         /* Fields set by Sash */
 251                         SelectionEvent event = new SelectionEvent (e);
 252                         ((SelectionListener) eventListener).widgetSelected (event);
 253                         e.x = event.x;
 254                         e.y = event.y;
 255                         e.doit = event.doit;
 256                         break;
 257                 }
 258                 case SWT.Show: {
 259                         ((MenuListener) eventListener).menuShown(new MenuEvent(e));
 260                         break;
 261                 }
 262                 case SWT.Touch: {
 263                         ((TouchListener)eventListener).touch(new TouchEvent(e));
 264                         break;
 265                 }
 266                 case SWT.Traverse: {
 267                         /* Fields set by Control */
 268                         TraverseEvent event = new TraverseEvent (e);
 269                         ((TraverseListener) eventListener).keyTraversed (event);
 270                         e.detail = event.detail;
 271                         e.doit = event.doit;
 272                         break;
 273                 }
 274                 case SWT.Verify: {
 275                         /* Fields set by Text, RichText */
 276                         VerifyEvent event = new VerifyEvent (e);
 277                         ((VerifyListener) eventListener).verifyText (event);
 278                         e.text = event.text;
 279                         e.doit = event.doit;
 280                         break;
 281                 }
 282         }
 283 }
 284
 285 }