home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Headers / driverkit / eventProtocols.h < prev    next >
Text File  |  1995-07-27  |  6KB  |  196 lines
  1. /*     Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved. 
  2.  *
  3.  * eventProtocols.h - ObjC protocols used by the Event Driver and it's clients.
  4.  *
  5.  * HISTORY
  6.  * 31 Mar 1992    Mike Paquette at NeXT
  7.  *      Created. 
  8.  * 4  Aug 1993      Erik Kay at NeXT
  9.  *     API cleanup
  10.  */
  11.  
  12. #import <driverkit/generalFuncs.h>
  13. #import <driverkit/driverTypes.h>
  14. #import <bsd/dev/ev_types.h>    /* Basic types for event system */
  15. #import <bsd/dev/event.h>    /* Event flags */
  16. #import <objc/objc.h>
  17.  
  18. /*
  19.  * Methods exported by the EventDriver to event source objects.
  20.  *
  21.  *    The IOEventSourceClient protocol is used by event source objects to
  22.  *    post state changes into the event driver.
  23.  *     The event driver implements this protocol.
  24.  */
  25. @protocol IOEventSourceClient
  26.  
  27. /*
  28.  * Called when another client wishes to assume ownership of calling 
  29.  * IOEventSource. This happens when a client attempts a becomeOwner: on a
  30.  * source which is owned by the callee of this method. 
  31.  *
  32.  * Returns:
  33.  *    IO_R_SUCCESS ==> It's OK to give ownership of the source to other client.
  34.  *               In this case, callee no longer owns the source.
  35.  *    IO_R_BUSY    ==> Don't transfer ownership.
  36.  *
  37.  * Note that this call occurs during (i.e., before the return of) a 
  38.  * becomeOwner: call to the caller of this method.
  39.  */
  40. - (IOReturn)relinquishOwnershipRequest    : source;
  41.  
  42. /*
  43.  * Method by which a client, who has registered "intent to own" via 
  44.  * desireOwnership:client, is notified that the calling device is available.
  45.  * Client will typically call becomeOwner: during this call.
  46.  */
  47. - (void)canBecomeOwner            : source;
  48.  
  49. /* Mouse event reporting */
  50. - relativePointerEvent:(int)buttons deltaX:(int)dx deltaY:(int)dy;
  51. - relativePointerEvent:(int)buttons
  52.         deltaX:(int)dx
  53.         deltaY:(int)dy
  54.         atTime:(ns_time_t)ts;
  55.  
  56. /* Tablet event reporting */
  57. - absolutePointerEvent:(int)buttons
  58.         at:(Point *)newLoc
  59.         inProximity:(BOOL)proximity;
  60. - absolutePointerEvent:(int)buttons
  61.         at:(Point *)newLoc
  62.         inProximity:(BOOL)proximity
  63.         withPressure:(int)pressure;
  64. - absolutePointerEvent:(int)buttons
  65.         at:(Point *)newLoc
  66.         inProximity:(BOOL)proximity
  67.         withPressure:(int)pressure
  68.         withAngle:(int)stylusAngle
  69.         atTime:(ns_time_t)ts;
  70.  
  71. /* Keyboard Event reporting */
  72. - keyboardEvent:(unsigned)eventType
  73.         flags:(unsigned)flags
  74.         keyCode:(unsigned)key
  75.         charCode:(unsigned)charCode
  76.         charSet:(unsigned)charSet
  77.         originalCharCode:(unsigned)origCharCode
  78.         originalCharSet:(unsigned)origCharSet
  79.         repeat:(BOOL)repeat
  80.         atTime:(ns_time_t)ts;
  81. - keyboardSpecialEvent:(unsigned)eventType
  82.         flags:(unsigned)flags
  83.         keyCode:(unsigned)key
  84.         specialty:(unsigned)flavor
  85.         atTime:(ns_time_t)ts;
  86. - updateEventFlags:(unsigned)flags;    /* Does not generate events */
  87.  
  88. /* Return current event flag values */
  89. - (int)eventFlags;
  90.  
  91. @end /* IOEventSourceClient */
  92.  
  93. /*
  94.  * The EventClient API lists generally useful methods exported by the Event
  95.  * driver.  These can be used by Event sources, or other users of the event
  96.  * system within the same address space.
  97.  */
  98. @protocol IOEventThread
  99.  
  100. /* 
  101.  * Event clients may need to use an I/O thread from time to time.
  102.  * Rather than have each instance running it's own thread, we provide
  103.  * a callback mechanism to let all the instances share a common Event I/O
  104.  * thread running in the IOTask space, and managed by the Event Driver.
  105.  */
  106. - (IOReturn)sendIOThreadMsg:    (SEL)selector    // Selector to call back on
  107.     to        :    (id)instance    // Instance to call back
  108.     with        :    (id)data;    // Data to pass back
  109.  
  110. /* Returns self, or nil on error. */
  111. - sendIOThreadAsyncMsg:        (SEL)selector    // Selector to call back on
  112.     to        :    (id)instance    // Instance to call back
  113.     with        :    (id)data;    // Data to pass back
  114.  
  115. @end /* IOEventThread */
  116.  
  117. /*
  118.  * Methods exported by IOEventSource objects.
  119.  */
  120. @protocol IOEventSourceExported
  121.  
  122. /*
  123.  * Register for event dispatch via IOEventSourceClient protocol. Returns
  124.  * IO_R_SUCCESS if successful, else IO_R_BUSY. The relinquishOwnershipRequest: 
  125.  * method may be called on another client during the execution of this method.
  126.  */
  127. - (IOReturn)becomeOwner        : client;
  128.  
  129. /*
  130.  * Relinquish ownership. Returns IO_R_BUSY if caller is not current owner.
  131.  */
  132. - (IOReturn)relinquishOwnership    : client;
  133.  
  134. /*
  135.  * Request notification (via canBecomeOwner:) when relinquishOwnership: is
  136.  * called. This allows one potential client to place itself "next in line"
  137.  * for ownership. The queue is only one deep.
  138.  */
  139. - (IOReturn)desireOwnership    : client;
  140.  
  141. @end /* IOEventSourceExported */
  142.  
  143. /*
  144.  * Methods exported by the EventDriver for display systems.
  145.  *
  146.  *    The screenRegister protocol is used by frame buffer drivers to register
  147.  *    themselves with the Event Driver.  These methods are called in response
  148.  *    to an _IOGetParameterInIntArray() call with "IO_Framebuffer_Register" or
  149.  *    "IO_Framebuffer_Unregister".
  150.  */
  151. @protocol IOScreenRegistration
  152.  
  153. - (int) registerScreen:    (id)instance
  154.         bounds:(Bounds *)bp
  155.         shmem:(void **)addr
  156.         size:(int *)size;
  157. - (void) unregisterScreen:(int)token;
  158.  
  159. @end /* IOScreenRegistration */
  160.  
  161.  
  162. /*
  163.  * Methods exported by compliant frame buffer drivers to the Event Driver.
  164.  *
  165.  *    Any frame buffer driver which will be used by the Window Server should
  166.  *    implement this protocol.  The methods in this protocol are invoked by
  167.  *    the Event Driver on command from the Window Server and from the pointer
  168.  *    management software.
  169.  * 
  170.  *    The frame field is an integer index into the driver's private array of
  171.  *    cursor bitmaps.  It is used to select the cursor to be displayed.
  172.  *    The token field is a small integer as returned by registerScreen, which
  173.  *    indicates which of the driver's screens should be used for drawing.
  174.  */
  175. @protocol IOScreenEvents
  176.  
  177. - (port_t) devicePort;
  178. - hideCursor: (int)token;
  179. - moveCursor:(Point*)cursorLoc frame:(int)frame token:(int)t;
  180. - showCursor:(Point*)cursorLoc frame:(int)frame token:(int)t;
  181. - setBrightness:(int)level token:(int)t;
  182.  
  183. @end    /* IOScreenEvents */
  184.  
  185. @protocol IOWorkspaceBounds
  186. /*
  187.  * Absolute position input devices and some specialized output devices
  188.  * may need to know the bounding rectangle for all attached displays.
  189.  * The following method returns a Bounds* for the workspace.  Please note
  190.  * that the bounds are kept as signed values, and that on a multi-display
  191.  * system the minx and miny values may very well be negative.
  192.  */
  193. - (Bounds *)workspaceBounds;
  194. @end
  195.  
  196.