home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / uicldd.zip / IDMTGTH.HPP < prev    next >
Text File  |  1993-09-03  |  11KB  |  268 lines
  1. #ifndef _IDMTGTH_
  2. #define _IDMTGTH_
  3. /*******************************************************************************
  4. * FILE NAME: idmtgth.hpp                                                       *
  5. *                                                                              *
  6. * DESCRIPTION:                                                                 *
  7. *   Declaration of the class(es):                                              *
  8. *     IDMTargetHandler - Drag/Drop target window handler.                      *
  9. *                                                                              *
  10. * COPYRIGHT:                                                                   *
  11. *   Licensed Materials - Property of IBM                                       *
  12. *   (C) Copyright IBM Corporation 1992, 1993                                   *
  13. *   All Rights Reserved                                                        *
  14. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  15. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  16. *                                                                              *
  17. * $Log:   S:/ibmclass/idrag/vcs/idmtgth.hpv  $
  18. //
  19. //   Rev 1.24   03 Sep 1993 11:19:44   HAGGAR
  20. //Added drag image support and made assorted fixes
  21. //
  22. //   Rev 1.23   02 Sep 1993 13:21:32   banzai
  23. //Interface changes per container
  24. //
  25. //   Rev 1.22   23 Aug 1993 15:34:18   banzai
  26. //Remove User Msg
  27. //
  28. //   Rev 1.21   22 Aug 1993 12:49:04   banzai
  29. //Remove Cnr headers
  30. //
  31. //   Rev 1.20   19 Aug 1993 15:11:16   banzai
  32. //Trace stuff & remove provider/setProvider
  33. //
  34. //   Rev 1.19   17 Aug 1993 12:45:50   law
  35. //Removed templates from i/f.
  36. //
  37. //   Rev 1.18   12 Aug 1993 13:53:28   banzai
  38. //Merge source and target item into one
  39. //
  40. //   Rev 1.17   10 Aug 1993 15:20:36   banzai
  41. //Make drag item provider into template
  42. //
  43. //   Rev 1.16   09 Aug 1993 14:35:46   MERLYN
  44. //No change.
  45. //
  46. //   Rev 1.15   09 Aug 1993 12:45:20   HAGGAR
  47. //rendering
  48. //
  49. //   Rev 1.14   05 Aug 1993 19:04:34   banzai
  50. //Clean up headers and function names
  51. //
  52. //   Rev 1.13   02 Aug 1993 13:38:56   banzai
  53. //Remove container constructor
  54. //
  55. //   Rev 1.12   29 Jul 1993 19:28:16   banzai
  56. //Move reuseable code to handlers per controls
  57. //
  58. //   Rev 1.11   17 Jul 1993 14:04:38   banzai
  59. //Fix trap on exit
  60. //
  61. //   Rev 1.10   15 Jul 1993 13:39:52   banzai
  62. //Limit creation of renderer associations on drag over
  63. //
  64. //   Rev 1.9   13 Jul 1993 18:01:00   banzai
  65. //It works
  66. //
  67. //   Rev 1.8   14 Jun 1993 17:00:16   banzai
  68. //Publicize renderer support
  69. //
  70. //   Rev 1.7   09 Jun 1993 16:09:44   banzai
  71. //More changes
  72. //
  73. //   Rev 1.6   19 May 1993 14:32:10   HAGGAR
  74. //
  75. //   Rev 1.5   19 May 1993 09:30:24   HAGGAR
  76. //
  77. //   Rev 1.4   18 May 1993 13:44:54   unknown
  78. //Enable drag item provider
  79. //
  80. //   Rev 1.3   05 May 1993 16:37:44   unknown
  81. //DM_DROP changes
  82. //
  83. //   Rev 1.2   03 May 1993 16:06:06   unknown
  84. //Latest changes per IC_UM_DRAGOVER
  85. //
  86. //   Rev 1.1   30 Apr 1993 11:45:46   HAGGAR
  87. //
  88. //   Rev 1.0   22 Apr 1993 10:41:16   HAGGAR
  89. //Initial revision.
  90. *******************************************************************************/
  91. #ifndef _IDMHNDLR_
  92.   #include <idmhndlr.hpp>
  93. #endif
  94.  
  95. #ifndef _IDMEVENT_
  96.   #include <idmevent.hpp>
  97. #endif
  98.  
  99. #ifndef _IDMRENDR_
  100.   #include <idmrendr.hpp>
  101. #endif
  102.  
  103. #ifndef _IENTRYFD_
  104.   #include <ientryfd.hpp>
  105. #endif
  106.  
  107. #ifndef _IMLE_
  108.   #include <imle.hpp>
  109. #endif
  110.  
  111. #if 0
  112. #ifndef _ISEQ_H
  113.   #include <iseq.h>
  114. #endif
  115. #endif
  116.  
  117. /* Forward Declarations */
  118. class IEvent;
  119. class IDMTargetEnterEvent;
  120. class IDMSourceNotifyEvent;
  121. class IDMTargetDropEvent;
  122. class IDMTargetEndEvent;
  123. class IDMTargetRenderer;
  124. class IDMTgtRendererSeq;
  125.  
  126. class IDMTargetHandler : public IDMHandler {
  127. typedef IDMHandler
  128.   Inherited;
  129. /*******************************************************************************
  130. * Objects of this class handle events occuring at target windows in direct     *
  131. * manipulation operations.  An instance of this class (or a derived class)     *
  132. * must be added to any window that will support direct manipulation from       *
  133. * that window.                                                                 *
  134. *                                                                              *
  135. * Example:                                                                     *
  136. * // Create frame window object ...                                            *
  137. * IFrameWindow                                                                 *
  138. *   frame( "ICLUI Direct Manipulation Sample" );                               *
  139. *                                                                              *
  140. * // Create client entry field and entry field extension objects ...           *
  141. * IEntryField                                                                  *
  142. *   client( 0, &frame, &frame ),                                               *
  143. *   ext   ( 0, &frame, &frame );                                               *
  144. *                                                                              *
  145. * // Define target handler for the entry field ...                             *
  146. * IDMTargetHandler                                                             *
  147. *   target( &client );                                                         *
  148. *                                                                              *
  149. * // Reuse target item provider in the extension that was instantiated         *
  150. * // for the client and configure the extension as a target handler            *
  151. * ext.setTargetItemProvider(client.itemProvider());                            *
  152. * target.handleEventsFor( &ext );                                              *
  153. *                                                                              *
  154. * Note:  Direct Manipulation support for the entry field is built into the     *
  155. *        class library.                                                        *
  156. *******************************************************************************/
  157. public:
  158. /*------------------------ Constructor/Destructor ------------------------------
  159. | Objects of this class are constructed as follows:                            |
  160. |                                                                              |
  161. | Note:  Constructors are provided that will construct target handlers         |
  162. |        designed specifically for the entry field and multi line edit         |
  163. |        controls.                                                             |
  164. ------------------------------------------------------------------------------*/
  165.   IDMTargetHandler     ( IEntryField *entryField );
  166.  
  167.   IDMTargetHandler     ( IMultiLineEdit *multiLineEdit );
  168.  
  169.   IDMTargetHandler     ( );
  170.  
  171.   ~IDMTargetHandler    ( );
  172.  
  173. /*------------------------------ Rendering -------------------------------------
  174. | These functions permit specificiation of derived IDMSourceRenderer objects   |
  175. | that will be used to handle rendering of dropped objects of compatible       |
  176. | types:                                                                       |
  177. |   numberOfRenderers - Returns the number of renderers.                       |
  178. |   renderer          - Returns the renderer with given index.                 |
  179. |   replaceRenderer   - Replaces a given renderer with another.                |
  180. |   addRenderer       - Associates another renderer with this operation.       |
  181. |   removeRenderer    - Removes a renderer from the operation.                 |
  182. ------------------------------------------------------------------------------*/
  183. unsigned
  184.   numberOfRenderers  ( );
  185.  
  186. IDMTargetRenderer
  187.  *renderer           ( unsigned           index );
  188.  
  189. IDMTargetHandler
  190.  &replaceRenderer    ( unsigned           index,
  191.                        IDMTargetRenderer  *replacement ),
  192.  &addRenderer        ( IDMTargetRenderer  *newItem ),
  193.  &removeRenderer     ( unsigned           index );
  194.  
  195.  
  196. protected:
  197.  
  198. /*------------------------------ Event Handling --------------------------------
  199. | These functions are dispatched in response to specific direct manipulation   |
  200. | target events:                                                               |
  201. |   targetEnter    - Called when dragged objects enter into/over the target    |
  202. |                    window.                                                   |
  203. |   targetLeave    - Called when the dragged objects are moved off the target  |
  204. |                    window.                                                   |
  205. |   targetDrop     - Called when the dragged objects are dropped on the        |
  206. |                    target window.                                            |
  207. |   sourceComplete - Called when the source has completed rendering of a       |
  208. |                    particular dragged object.                                |
  209. |   targetHelp     - Called when the user has requested help while dragging    |
  210. |                    over the target window.                                   |
  211. ------------------------------------------------------------------------------*/
  212. virtual Boolean
  213.   targetEnter       ( IDMTargetEnterEvent  &event ),
  214.  
  215.   targetLeave       ( IDMSourceNotifyEvent &event ),
  216.   targetDrop        ( IDMTargetDropEvent   &event ),
  217.   targetHelp        ( IDMSourceNotifyEvent &event ),
  218.  
  219.   sourceComplete    ( IDMTargetEndEvent    &event );
  220.  
  221. /*------------------------------ Implementation --------------------------------
  222. | The following utility functions are used to implement the behavior of        |
  223. | this class:                                                                  |
  224. |   setRenderers        - Sets the pointer to the collection of                |
  225. |                         IDMTargetRenderers.                                  |
  226. |   rendererCollection  - Returns a reference to the collection of             |
  227. |                         IDMTargetRenderers.                                  |
  228. ------------------------------------------------------------------------------*/
  229. //virtual IDMTargetHandler
  230. //  &setRenderers      ( IDMTgtRendererSeq *renderers );
  231.  
  232. IDMTgtRendererSeq
  233.   &rendererCollection  ( );
  234.  
  235. /*-------------------------------- Overrides -----------------------------------
  236. | This class overrides the following inherited functions:                      |
  237. |   dispatchHandlerEvent - Dispatching function; handles drag target events.   |
  238. ------------------------------------------------------------------------------*/
  239. virtual Boolean
  240.   dispatchHandlerEvent ( IEvent &event );
  241.  
  242.  
  243. private: /*------------------------ PRIVATE ----------------------------------*/
  244. friend class IDMCnrTargetHandler;
  245.  
  246. Boolean
  247.   assocItmsToRndrs(IDMTargetEnterEvent &event);
  248.  
  249. IDMTargetRenderer
  250.  *rendererInUse();
  251.  
  252. void
  253.   setRendererInUse(IDMTargetRenderer *pTgtRndr);
  254.  
  255. IDMTgtRendererSeq
  256.  *tgtRenderersSeqCl;
  257.  
  258. IDMTargetRenderer
  259.   *pTgtRenderer;
  260.  
  261. }; // IDMTargetHandler
  262.  
  263. #ifndef I_NO_INLINES
  264.   #include <idmtgth.inl>
  265. #endif
  266.  
  267. #endif // _IDMTGTH_
  268.