home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ucmenu.zip / UCMENUS.PAK / SOURCE / UCMENUS.C < prev    next >
C/C++ Source or Header  |  1995-09-28  |  554KB  |  13,404 lines
  1. /***************************************************************************/
  2. /***************************************************************************/
  3. /*                        DISCLAIMER OF WARRANTIES.                        */
  4. /***************************************************************************/
  5. /***************************************************************************/
  6. /*                                                                         */
  7. /*  Copyright (C) 1995 IBM Corporation                                     */
  8. /*                                                                         */
  9. /*      DISCLAIMER OF WARRANTIES.  The following [enclosed] code is        */
  10. /*      sample code created by IBM Corporation. This sample code is not    */
  11. /*      part of any standard or IBM product and is provided to you solely  */
  12. /*      for  the purpose of assisting you in the development of your       */
  13. /*      applications.  The code is provided "AS IS", without               */
  14. /*      warranty of any kind.  IBM shall not be liable for any damages     */
  15. /*      arising out of your use of the sample code, even if they have been */
  16. /*      advised of the possibility of such damages.                        */
  17. /***************************************************************************/
  18. #pragma alloc_text ( CODESTARTKEEP, UCMenuDrgDrpMsg               )
  19. #pragma alloc_text ( CODESTARTKEEP, MyMalloc                      )
  20. #pragma alloc_text ( CODESTARTKEEP, MenuWndProc                   )
  21. #pragma alloc_text ( CODESTARTKEEP, UCMenuWndProc                 )
  22. #pragma alloc_text ( CODESTARTKEEP, BubbleWndProc                 )
  23. #pragma alloc_text ( CODESTARTKEEP, UCMenuCalcUnscaledItemSize    )
  24. #pragma alloc_text ( CODESTARTKEEP, UCMenuCalcItemSize            )
  25. #pragma alloc_text ( CODESTARTKEEP, UCMenuCalcTextSize            )
  26. #pragma alloc_text ( CODESTARTKEEP, SubmenuWndProc                )
  27. #pragma alloc_text ( CODESTARTKEEP, CreateUCMenu                  )
  28. #pragma alloc_text ( CODESTARTKEEP, UCMenuCalcBmpPos              )
  29. #pragma alloc_text ( CODESTARTKEEP, MyFree                        )
  30. #pragma alloc_text ( CODESTARTKEEP, UCMenu3DFrame                 )
  31. #pragma alloc_text ( CODESTARTKEEP, HideWndProc                   )
  32. #pragma alloc_text ( CODESTARTKEEP, GetMaxItemSize                )
  33. #pragma alloc_text ( CODESTARTKEEP, UCMenuCheckScrolling          )
  34. #pragma alloc_text ( CODESTARTKEEP, UCMenuSetBmpBgColor           )
  35. // (MAM) Added to KEEP code seg:
  36. #pragma alloc_text ( CODESTARTKEEP, UCAdjacentItemBlank           )
  37.  
  38. #pragma alloc_text ( CODESTARTDROP, UCMenuGetBitmapFullName       )
  39. #pragma alloc_text ( CODESTARTDROP, UCMenuLoadBitmap              )
  40. #pragma alloc_text ( CODESTARTDROP, UCMenuLoadMenuData            )
  41. #pragma alloc_text ( CODESTARTDROP, UCMenuLoadItemBmp             )
  42. #pragma alloc_text ( CODESTARTDROP, UCMenuGetBitmapPath           )
  43. #pragma alloc_text ( CODESTARTDROP, UCMenuSelectColor             )
  44. #pragma alloc_text ( CODESTARTDROP, UCMenuCreateFromTemplate      )
  45. #pragma alloc_text ( CODESTARTDROP, UCMenuCreate                  )
  46.  
  47. //----------------------------------------------------------------------------
  48. //
  49. // UCMENUS.C
  50. //
  51. // User-Customizable Menus utility
  52. //-------------------------------------+--------------------------------------
  53. //                                     |   Advanced Commercial Applications
  54. // Version: 2.01                       |   IBM T.J. Watson Research Center
  55. //                                     |   P.O. Box 218
  56. //                                     |   Yorktown Heights, NY 10598
  57. //-------------------------------------+--------------------------------------
  58. // History:
  59. // --------
  60. //
  61. // created: Feb 10 1993 by Alex BERTRAND
  62. //
  63. // updates: Jun 20 1993 (AB) : Save/Load Menu Template functions
  64. //          Jul 10 1993 (AB) : Pop-up menus (Settings)
  65. //          Aug 04 1993 (AB) : Drag and Drop support
  66. //          Oct 04 1993 (GLS): UCS_ styles
  67. //          Feb 01 1994 (GLS): More Drag and Drop support
  68. //          ===> Build Version 2.01
  69. //          Mar 07 1995 (MAM): Fixed drag/drop of MIS_SPACER items
  70. //          Mar 07 1995 (MAM): Added new bitmap for dragging of spacers (diff from no-bmp items)
  71. //          Mar 07 1995 (MAM): Don't draw edges of adjacent spacer items
  72. //          Mar 15 1995 (MAM): Delete bitmap loaded for drag/drop (plug possible memory leak)
  73. //          Mar 15 1995 (MAM): Fix truncated text on customization dialog
  74. //          Mar 15 1995 (MAM): Added OK/Cancel buttons to customzation dlg, remove confirm box
  75. //          Mar 15 1995 (MAM): Clarified some messages (NLS_xxxx in ucmenus.rc)
  76. //          Mar 21 1995 (MAM): Fixed some missing notify messages when items drag/dropped
  77. //                               -- e.g. only UCN_ADDEDITEM was generated, no UCN_DELETEDITEM
  78. //          Mar 23 1995 (MAM): Fixed many problems with submenus:
  79. //                               -- was unable to drag/drop reoder items in a submenu
  80. //                               -- drag from a submenu left some junk pixels when menu dismissed
  81. //                               -- drag from a submenu did not delete source item (e.g. copied)
  82. //                               -- context menu left dark grey line on main menu
  83. //                               -- missing many UCN_* notify messages when submenus customized
  84. //                               -- mouse-move notify messages gave incorrect item IDs
  85. //                               -- style changes did not change already-opened submenus.  changing
  86. //                                  text of a submenu item did not resize the submenu (autoresize style)
  87. //                               -- SUBMENU placeholders cannot be MIA_NODISMISS, each individual item of
  88. //                                  the submenu to be non-dismissable must have MIA_NODISMISS attribute.
  89. //                                  (This is different than std PM menus, but necessary to prevent
  90. //                                  dismiss of submenus during drag/drop operations).
  91. //          Mar 23 1995 (MAM): UCMenuIdFromCoord() off by one pixel on right/top edges
  92. //          Mar 23 1995 (MAM): Made checkmark (thick brdr) visible on hilited items (3-pel thick bdr)
  93. //          Mar 24 1995 (MAM): Remove ability to use MIS_BREAK on submenus
  94. //                               -- PM bug gives wrong coordinates on MM_QUERYITEMRECT for submenus w/BREAK
  95. //          Mar 24 1995 (MAM): Updated version to "2.02" (ucmenus.h)
  96. //         ----------------------------- Version 2.02 Build (DevCon CD, Volumne 7) ----------------------------------------
  97. //          Mar 27 1995 (MAM): Dismiss submenu before sending WM_CONTROL msg to owner (non-NODISMISS items).
  98. //          Mar 29 1995 (MAM): Dismiss submenu before deleting parent menu item.
  99. //          Mar 29 1995 (MAM): Dismiss submenu before processing WM_DESTROY.
  100. //          Mar 29 1995 (MAM): Remove MIA_NODISMISS attribute when copy/moving parent item of a submenu
  101. //         ----------------------------- Version 2.03 Build (Compuserve) ----------------------------------------
  102. //          Apr 04 1995 (MAM): Improved UCN_MOUSEMOVE control messages:
  103. //                               - Only get message when ID changes instead of every movement
  104. //                               - Always get final msg with ID=0 when mouse leaves menu window
  105. //          Apr 05 1995 (MAM): Replace (HWND)0 with NULLHANDLE for better portability.
  106. //          Apr 05 1995 (MAM): Fix prototype of UCMenuGetVersion() and include <stddef.h>  (Thanks Bill K.)
  107. //          Apr 10 1995 (MAM): Use WinDrawText() to measure space needed for text strings.  GpiQueryTextBox() not always accurate.
  108. //          Apr 12 1995 (MAM): Add support for bubble-help
  109. //                               - UCS_BUBBLEHELP style flag
  110. //                               - UCN_QRYBUBBLEHELP WM_CONTROL message to application
  111. //                                   update passed structure w/string (freed by UCmenus when done --
  112. //                                   app must allocate string with UCMenuAlloc()).
  113. //                               - UCMENU_SETBUBBLETIMERS:
  114. //                                    mp1 = (LONG) new delay in msec, maximum of 65000 (65 seconds)
  115. //                                    mp2 = (LONG) new read-time in msec
  116. //                                    returns 0 (reserved)
  117. //                               App must supply initial delay in UCMINFO data
  118. //          ---NOTE--- Need to recompile apps to get larger UCMINFO structure size
  119. //          Apr 13 1995 (MAM): Remove code to un-hilight current item when context menu invoked
  120. //                               (did not work, no longer needed anyway)
  121. //          Apr 13 1995 (MAM): Add support for application-supplied context menu:
  122. //                               - UCN_QRYCONTEXTHWND message
  123. //                                   mp1 = (UCMenu ID, UCN_QRYCONTEXTHWND)
  124. //                                   mp2 = ptr to MENUITEM structure (usID zero if not over an item)
  125. //                                   return HWND of application popup menu, or NULL if none
  126. //                               - Owner of UCMenu control will get UCN_CMITEM ctrl messages (just like built-in menu)
  127. //          Apr 21 1995 (MAM): Fix: always register UCMenu window class in case DLL is freed
  128. //                             and reloaded by the same process (otherwise class points to window
  129. //                             proc in old freed DLL instance).
  130. //          Apr 21 1995 (MAM): Added UCMINRES.RES to build process to create minimal-resource .RES
  131. //                             file.  For use by apps that don't use the UCMenus built-in context
  132. //                             menu or customization dialogs.
  133. //          Apr 24 1995 (MAM): Fix possible trap in UCMenuSetBmpBgColor() due to uninitialized ptr
  134. //          Apr 24 1995 (MAM): Changed all "(TYPE)0" null pointers to "NULL" or "NULLHANDLE" as appropriate
  135. //          Apr 24 1995 (MAM): Added UCMenuStrdup() to API set (useful during UCN_QRYBUBBLEHELP).
  136. //          Apr 24 1995 (MAM): Changed internal use of UCMenuFree() to MyFree() -- eliminate func call in non-debug mode
  137. //          Apr 25 1995 (MAM): Code cleanup, removed lots of unused vars, etc.
  138. //          Apr 26 1995 (MAM): Don't process MM_DELETEITEM for submenu item in main menu proc.
  139. //          Apr 27 1995 (MAM): Added UCMENU_ACTIVECHG message -- reqd for apps using UCN_BUBBLEHELP style
  140. //                                mp1 = (SHORT1) TRUE -- app is being activated
  141. //                                               FALSE-- app is being deactivated
  142. //                                      (SHORT2) Reserved
  143. //                                mp2 = Reserved
  144. //          Apr 27 1995 (MAM): Dismiss open submenus when app becomes inactive
  145. //          May 01 1995 (MAM): Fixed drawing of overall menu frame when !UCN_FRAMED
  146. //          May 01 1995 (MAM): Chg meaning of UCS_FORCESIZE (just sets size of bitmap, item still sizes to larger of bitmap or text)
  147. //                                (e.g. text is NEVER clipped).  Also FORCESIZE can now scale
  148. //                                the bitmap up or down in size (instead of just down).
  149. //          May 02 1995 (MAM): Added UCMENU_QUERYRECT message to get position of a menu item in UCMenu window
  150. //          May 02 1995 (MAM): Added UCMENU_DISABLEUPDATE to improve performance when app inserts/deletes lots of items
  151. //                                mp1 = (BOOL)  TRUE -- do not update menu
  152. //                                              FALSE-- update when needed
  153. //                                mp2 = reserved
  154. //                             Application should always send UCMENUS_UPDATE after re-enabling update.
  155. //                             Initial state is disabled=FALSE (e.g. update on every insert/delete, etc).
  156. //          May 08 1995 (MAM): Chngd UCMENU_QUERYSIZE to return real size for CMS_MATRIX style (instead of size based in num of row/cols requested)
  157. //          May 09 1995 (MAM): Added UCMenuItemDup() and UCMenuItemFree() functions to copy/free UCMITEM structures
  158. //          May 10 1995 (MAM): Added UCN_CHANGEDITEM msg when MM_SETITEM or MM_SETITEMHANDLE is received (notify of change to item, extent of change is unknown)
  159. //          May 15 1995 (MAM): Fixed memory leak by freeing pszParameters when item is deleted (MM_DELETEITEM processing)
  160. //          May 24 1995 (MAM): Use UCMString2Int() to better distinguish btw bitmap resource numbers and file names (previous code would take "123G.BMP" as resource ID 123).
  161. //          May 24 1995 (MAM): Store binary form of bitmap ID in upper word of ulFlags in UCMITEM structure
  162. //          May 24 1995 (MAM): UCMI_FROMBMPFILE in ulFlags is set if pszBmp[] is a filename (even if the file was not found and a default resource bitmap is being used instead)
  163. //          May 24 1995 (MAM): pszDefaultBitmap in UCMINFO can now be a resource ID (string form) or a file name
  164. //          May 25 1995 (MAM): Fix bug in algorithm for choosing best bitmap when .BMP file contains array of bitmaps
  165. //         June 03 1995 (MAM): Fix test of uninitialized variable in UCMenuNew().
  166. //         June 06 1995 (MAM): Enhanced UCMenuLoadBitmap() to load icons from non-BMP files using WinLoadFileIcon.  Makes it easy to show WPS representation of any file.
  167. //                               -- Commented out because of black-background problem (requires more code to solve).
  168. //         June 06 1995 (MAM): If toolbar is empty set size to size of a normal PM menu.
  169. //         June 13 1995 (MAM): Changed UCMENUS.RCH to UCMLOCAL.H (some build systems need .H extension for all header files)
  170. //         June 13 1995 (MAM): Fixed trap/hang if application had its own drag/drop implementation in addition to the UCMenu control
  171. //                               (dragging over the UCMenu from a same-process, non-UCMenu window would trap/hang due to bad assumption in DM_DRAGOVER processing)
  172. //         July 20 1995 (MAM): Changed background color mapping of bitmaps:
  173. //                              - Added new style "UCS_CHNGBMPBG_AUTO" to use lower-leftmost pixel of bitmap to determine bitmap background color (BgBmp of UCMINFO will be ignored)
  174. //                              - Improved UCMenuSetBmpBgColor() to not assume 256 color bitmaps (less memory allocated and better performance for 2 or 16-color bitmaps)
  175. //                              - Bitmap backgrounds are now mapped (only) when bitmaps are loaded (not at WM_DRAWITEM time)
  176. //                              - All bitmaps are reloaded (and color mapped) when the menu background color is changed (fixes bug where multiple color changes would lose colors in the bitmaps)
  177. //                              - Removed lCurBmpBgColor from UCMITEM structure (no longer needed since colors are mapped only when bitmaps are loaded)
  178. //         July 20 1995 (MAM): Removed use of BitBlt to shift image of items during hilight/unhilight (BltBit method leaves stray pixels in many cases when item is partially obscured by another window).
  179. //                              Now just fully draw the item every time.  Less efficient but more robust.
  180. //         July 21 1995 (MAM): Fixed spurious display of bubble help when pointer passes through toolbar (check for ptr in toolbar window during WM_TIMER (TIMER_BUBBLE) processing)
  181. //         July 21 1995 (MAM): Reduced timer for detecting ptr leaving toolbar to 1/2 second
  182. //         July 21 1995 (MAM): Fixed visual corruption when bubble is removed if underlaying window changed (remove WS_SAVEBITS style)
  183. //         July 21 1995 (MAM): Fixed visual corruption when bubble is quickly hidden/shown (get/dispatch all WM_PAINT messages between HIDE/SHOW so underlaying windows are sure to paint)
  184. //         July 21 1995 (MAM): Added several HWNDs to UCMDATA to elimiate many WinQueryWindow() calls.
  185. //         July 21 1995 (MAM): Added UCMUI #define to create smaller module with no user-customization or context menu functions.
  186. //         ----------------------------- Version 2.1 Build ----------------------------------------
  187. //         Aug  08 1995 (MAM): Activate frame on button 2 down (prevent context menu on inactive frame)
  188. //         Aug  10 1995 (MAM): Fix render of larger fonts by getting new PS in WM_DRAWITEM instead of using PS supplied by PM
  189. //         Aug  16 1995 (MAM): Removed MIS_TEXT bit flag from MIS_SPACER definition -- OS/2 2.1 does not send WM_MEASUREITEM messages if MIS_TEXT flag is set
  190. //         Aug  29 1995 (MAM): Fixed double-painting of toolbar when sized after creationg (changed WM_SIZE from Post to Send)
  191. //         Aug  29 1995 (MAM): Comment-out UCMENUS_DEBUG for memory allocate
  192. //         Aug  30 1995 (MAM): Fix memory leak from unclosed device context (WM_DESTROY processing)
  193. //         Sept  1 1995 (MAM): Fix memory leak from unfreed drag/drop transfer shared memory
  194. //         Sept 14 1995 (MAM): Improved scrolling algorithms (don't reset scroll posn when window size changes)
  195. //         Sept 18 1995 (MAM): Fixed UCN_SIZE notification logic to only send size change notification when dimension of interest changes (e.g. vert dim of a HORZ menu)
  196. //         Sept 21 1995 (MAM): Fixed painting of disabled menu items (render our own half-tone).
  197. //         Sept 28 1995 (MAM): Added CMS_MATRIX_VERT and CMS_MATRIX_HORZ styles for scrollable matrix menus
  198. //         ----------------------------- Version 2.11 Build ----------------------------------------
  199. //----------------------------------------------------------------------------
  200. // Nice to-dos for future versions:
  201. //
  202. // - consolidate bubble-handling of button and context menus to one function
  203. // - fix accelarator handling or remove the capability ("~" in text)
  204. // - Optimize repainting for performance:
  205. //    - On size change, repaint entire bar only if:
  206. //         - vertical size changed, or
  207. //         - scroll bar status (on/off) changed
  208. //         otherwise repaint only items affected by the resizing.
  209. //    - On insert/delete, repaint only toolbar area
  210. //      to the right of the inserted/delete item.  Repaint entire
  211. //      bar only if insert/delete causes change in scrollbar status.
  212. //
  213. // - put mouse capture code into Hide window and modify bubble
  214. //   proc to not change active status when pointer moves into hide window.
  215. //   Have hide window generate dummy ID?
  216. //
  217. // - improve loading of bitmaps from resource file by accessing
  218. //   bitmap resource directly and using same bitmap selection algorithm as
  219. //   UCMenuLoadBitmap() does loading from a file (e.g. select resolution
  220. //   *closest* to screen size instead of exact-match only).
  221. //
  222. //----------------------------------------------------------------------------
  223. // Known problems/limitations:
  224. //
  225. //  - Bug in Warp 3.0 can cause corruption of a random toolbar bitmaps
  226. //    during drag/drop operations.  No known workaround. 
  227. //    This problem does not occure on 2.X versions of OS/2.  Severity 1 APAR
  228. //    submitted to Boca, APAR number PJ17913.  Fixed in fix pack #9.
  229. //
  230. //  - Bug in Warp 3.0 causes 64K byte memory leak on every use of WinFileDlg().
  231. //    APAR number PJ16382.  Fixed in fix pack #9.
  232. //
  233. //  - Cannot support MIS_BREAK on submenus due to PM bug in MM_QUERYITEMRECT
  234. //    which can return wrong coordinates when an OWNERDRAW submenu has breaks.
  235. //    Any MIS_BREAK style flags will be removed when the UCMenu is created.
  236. //    Need to create simple testcase and submit OS/2 defect report.
  237. //
  238. //  - Bubble window on submenus not implemented.
  239. //
  240. //----------------------------------------------------------------------------
  241. // Includes
  242. //----------------------------------------------------------------------------
  243. #define INCL_BASE
  244. #define INCL_PM
  245. #define INCL_WINSTDDRAG
  246. #define MTI_INCLUDED   // PM menu templates
  247. #include <os2.h>
  248. #include <stdio.h>
  249. #include <stdlib.h>
  250. #include <string.h>
  251. #include <ctype.h>
  252. #include <stddef.h>
  253.  
  254. #define OPENREAD(fn)   fopen(fn, "rb")
  255. #define OPENWRITE(fn)  fopen(fn, "wb")
  256. #define FILEHANDLE     FILE *
  257. #define NULLFILE       NULLHANDLE
  258. #define CLOSEFILE(h)   fclose(h)
  259. #define READFILE(Buff,Size,Cnt,h)  fread(Buff, Size, Cnt, h)
  260. #define WRITEFILE(Buff,Size,Cnt,h) fwrite(Buff, Size, Cnt, h)
  261. #define pcslstrchr     strchr
  262. #define SEEKOK(rc)     (rc==0)
  263. #define AnsiUpperBuff(str,len) strupr(str)
  264.  
  265. #include "UCMENUS.H"     // Externalized definitions
  266. #include "UCMLOCAL.H"    // Internal definitions
  267.  
  268. //------------------------------------------------------------------------
  269. // Remove the following to generate a smaller module without
  270. // any user-customization functions.  Application-supplied context
  271. // menu will work, but UCMenu will have no context menu of its own.
  272. // Also the UCMenu...BuffetDlg() functions do nothing.  This is for
  273. // use in applications which supply all context menu and customization
  274. // functions.
  275. //------------------------------------------------------------------------
  276. #define UCMUI
  277.  
  278. //...use 2nd for real build...
  279. //#define DRAGDEBUG (PVOID)0x80000000        // Allow msg dispatching during DrgDrag().
  280. #define DRAGDEBUG NULL                       // Normal drag
  281.  
  282. // ---------------------------------------------------
  283. // -- Memory allocation switches,
  284. // ---------------------------------------------------
  285. #ifdef DEBUGMENUS
  286.     #define UCMENUS_DEBUG
  287. #else
  288.    #undef UCMENUS_DEBUG
  289. #endif
  290. // #define UCMENUS_DEBUG           // -- switches on debug mem allocation
  291. // #define MYMALLOC_RIGHT_BOUNDARY // -- switches the debug mem alloc on right boundary
  292.  
  293. //----------------------------------------------------------------------------
  294. // Debug memory allocations
  295. //----------------------------------------------------------------------------
  296.  
  297. // -------------------------------------------------------------------------------------
  298. // -- The non debug version uses malloc, which does less checkings than DosAllocMem
  299. // -- So when debugging, we use DosAllocMem, which will trap earlier than malloc in case
  300. // -- of access violation. But the granularity of DosAllocMem is 1 page (4096 bytes) so
  301. // -- if we want to check the violations at the right boundary of the memory we allocate
  302. // -- we put the end of the memory on a page boundary.
  303. // -------------------------------------------------------------------------------------
  304.  
  305.  
  306. #ifdef UCMENUS_DEBUG
  307.    VOID  * MyMalloc(size_t size);
  308.    VOID    MyFree(VOID * p);
  309.    char  * MyStrdup(const char * string);
  310.    #define ERRPRT0(a)       fprintf(stderr,a)
  311.    #define ERRPRT1(a,b)     fprintf(stderr,a,b)
  312.    #define ERRPRTKEEP1(a,b) fprintf(stderr,a,b)
  313. #else
  314.    #define MyMalloc malloc
  315.    #define MyFree   free
  316.    char  * MyStrdup(const char * string);
  317.    #define ERRPRT0(a)
  318.    #define ERRPRT1(a,b)
  319.    #define ERRPRTKEEP1(a,b) b
  320. #endif
  321.  
  322.  
  323. //----------------------------------------------------------------------------
  324. // local constants
  325. //----------------------------------------------------------------------------
  326. #define UCAPPNAME   "UCMenus"     //MEK 09/15/94 - for ini file processing
  327. #define UCKEYNAME   "UCKeyName"
  328. #define UCMCLASS    "UCMenu"      // UCMenu window class
  329. #define BUBBLECLASS "UCMBbl"      // Bubble-help window class
  330. #define MAXDESCLEN 256
  331. #define MAX_TMPSIZE 16384
  332. #define MAX_FONTNAMELEN 100       // Max length of a font name
  333. #define MAX_INT         32767     // Max SHORT integer
  334. #define DEFAULT_DELAY   2500      // Default bubble delay time in msec.
  335. #define MIN_BUBBLE_DELAY 150      // Less delay than this treated as zero delay
  336. #define QWL_UCMDATA  4
  337. #define PTR_CHECK_DELAY  500L     // Interval for checking ptr leaving toolbar windows
  338. #define BBLDISMISS_DELAY 4000L    // Auto dismiss of bubble help
  339.  
  340. #define GETTING_FOCUS   WM_USER +  0x1000  // Note UCMENU_* start with 0x2000
  341. #define UCMNBP1_NEWBMP  WM_USER +  0x1001
  342. #define MSG_ITEMCHANGE  WM_USER +  0x1002  // Notice to bubble window ptr moved to diff item
  343. #define MSG_ENABLE_BUBBLE  WM_USER+0x1003  // Enable bubble window
  344. #define MSG_DISABLE_BUBBLE WM_USER+0x1004  // Disable bubble window
  345. #define MSG_UPDATE_BUBBLE  WM_USER+0x1005  // Used internally in bubble window proc
  346.  
  347. #define TIMER_BUBBLE       TID_USERMAX-1   // Timer ID for buble help
  348. #define TIMER_BUBBLE_FAKE  TID_USERMAX-2   // Pseudo timer event ID
  349. #define TIMER_PTRCHECK     TID_USERMAX-3   // Check ptr for in/out of menu window
  350. #define TIMER_BBLAUTODISMISS TID_USERMAX-4 // Auto dismiss of bubble help window
  351. // --
  352. // maximum size of the bitmap drawn while dragging
  353. // --
  354. #define UCM_MAX_DRG_CX 100
  355. #define UCM_MAX_DRG_CY 100
  356. // --
  357. // We leave a 2 pixel frame around the item
  358. // --
  359. #define ITEM_FRAME_THICK_LEFT       2
  360. #define ITEM_FRAME_THICK_RIGHT      2
  361. #define ITEM_FRAME_THICK_BOTTOM     2
  362. #define ITEM_FRAME_THICK_TOP        2
  363. #define SUM_ITEM_FRAME_THICK_HORZ   4
  364. #define SUM_ITEM_FRAME_THICK_VERT   4
  365. // --
  366. // We leave some space right and left of the text
  367. // --
  368. #define TEXT_FRAME_THICK_HORZ       1
  369. #define SUM_TEXT_FRAME_THICK_HORZ   2
  370. // --
  371. // There is a frame around the ucmenu (actually it is the frame
  372. //  of the scrollbar which has the same size as the UCM and is drawn
  373. //  over it)
  374. // --
  375. #define UCM_FRAME_THICK             1
  376. #define SUM_UCM_FRAME_THICK         2
  377. // --
  378. // There is a frame around the menu (it is drawn in the hide window
  379. //  which is drawn inside the ucmenu frame )
  380. // --
  381. #define MENU_FRAME_THICK            1
  382. #define SUM_MENU_FRAME_THICK        2
  383. // --
  384. // (MAM) Added constants
  385. // Constants for UCAdjacentItemBlank() Left/Right parameter
  386. //
  387. #define ADJACENT_LEFT               -1
  388. #define ADJACENT_ABOVE              -1
  389. #define ADJACENT_RIGHT              1
  390. #define ADJACENT_BELOW              1
  391.  
  392. #if defined(_LE_PPC)                                                    
  393. //----------------------------------------------------------------------
  394. // GpiQueryColorData is OK under OS/2 for PowerPC SDK.                  
  395. //----------------------------------------------------------------------
  396. #define GpiQueryColordata GpiQueryColorData                             
  397. #else                                                                   
  398. #endif /* _LE_PPC */                                                    
  399.  
  400. //----------------------------------------------------------------------------
  401. // Macros
  402. //----------------------------------------------------------------------------
  403. #define POST_TO_MENU  (MRESULT)WinPostMsg(UCMData->hwndMenu, msg, mp1, mp2)
  404. #define SEND_TO_MENU  WinSendMsg(UCMData->hwndMenu, msg, mp1, mp2)
  405. #define MSGBOX(Owner,Title,Msg) WinMessageBox(HWND_DESKTOP,Owner,Msg,Title,0,MB_OK|MB_INFORMATION)
  406.  
  407. //----------------------------------------------------------------------------
  408. // local structures
  409. //----------------------------------------------------------------------------
  410.  
  411. typedef struct _UCMDATA {  // Main structure we hang off most window words, has all kinds of useful stuff
  412.    ULONG        size                ;             // Size of this structure
  413.    PFNWP        OldMenuProc         ;             // We subclass the menu & submenu window procedure
  414.    PFNWP        OldSubMenuProc      ;
  415.    HWND         hwndOwner           ;             // Owner of UCMenu
  416.    HWND         hwndUCM             ;             // UCMenu window handle
  417.    HWND         hwndHide            ;             // Hide window handle
  418.    HWND         hwndScroll          ;             // Scrollbar window handle
  419.    HWND         hwndCM              ;             // context menu : loaded once.
  420.    HWND         hwndUserCM          ;             // context menu provided by application, if any
  421.    HWND         hwndMenu            ;             // Handle of the PM menu associated to the ucmenu
  422.    HWND         hwndCMOrig          ;             // Handle of the (sub)menu from which the CM was popped
  423.    HWND         hwndHelpInstance    ;             // Handle of the help instance
  424.    HWND         hwndBubble          ;             // Bubble-help (hover) window
  425. #if defined(UCMUI)
  426.    HWND         hwndTemp            ;             // Temporary window handle
  427.    HWND         hwndSettings        ;             // Window handle of the settings dialog
  428.    HWND         hwndPage1           ;             // Pages of the dialog
  429.    HWND         hwndPage2           ;
  430.    HWND         hwndPage0           ;
  431. #endif
  432.    ULONG        MaxVerticalWidth    ;             // The widest item of vertical UCMENU
  433.    ULONG        MaxHorizontalHeight ;             // The tallest item of horizontal UCMENU
  434.    ULONG        SumItemWidths       ;
  435.    ULONG        SumItemHeights      ;
  436.    ULONG        Style               ;
  437.    ULONG        cx                  ;             // Size to give to all the items if UCS_FORCESIZE
  438.    ULONG        cy                  ;             //
  439.    ULONG        BubbleDelay         ;             // Bubble-help delay (msec)
  440.    ULONG        BubbleRead          ;             // Bubble-help read time (msec)
  441.    ULONG        ulBmpTempId;
  442.    ULONG        MenuPtrTimer        ;             // Timer handle for menu window
  443.    LONG         BgColor             ;             // RGB value of the current background color
  444.    LONG         ItemBgColor         ;             // RGB value of the current item background color
  445.    LONG         BgBmp               ;             // RGB value of the initial bitmap color to be replaced with ItemBgColor
  446.    HMODULE      hModUCM             ;             // Module that we use...
  447.    HMODULE      hModBmp             ;             // Module where we look for the bitmaps
  448.    HBITMAP      hBmpTemp            ;             // Temporary bitmap handle
  449.    HPS          hpsMem              ;             // HPS associated to a mem device context, to perform bitmap manipulations
  450.    PACCELTABLE  AccelTable          ;
  451.    PSZ          pszFontNameSize     ;             // Font of the ucmenu
  452.    USHORT       UCMenuID            ;             // ID of UCMenu window
  453.    USHORT       usItem              ;             // ID of the current submenu
  454.    USHORT       ContextID           ;             // ID of the item over which the context menu is called
  455.    USHORT       TargetID            ;             // ID of the item being target of a drag&drop
  456.    USHORT       HoverID             ;             // ID of item the mouse is hovering over
  457.    USHORT       MinID, MaxID        ;
  458.    USHORT       NbOfRows            ;
  459.    USHORT       NbOfCols            ;
  460.    BOOL         bBmpTempFromFile    ;             // TRUE if hBmpTemp from file, FALSE if from resource
  461.    BOOL         bItemCreation       ;             // TRUE if we are creating an item
  462.    BOOL         bProcessingPP       ;             // TRUE if we are processing a WM_PRESPARAMCHANGED
  463.    BOOL         Active              ;             // Is our app active?  Track UCMENU_ACTIVECHG status.
  464.    BOOL         DisableUpdate       ;             // Update disabled by owner
  465.    TID          tid;                              // Used to store temp thread ids
  466. #if defined(UCMUI)
  467.    CHAR         szTemplatePath[CCHMAXPATH];       // Last path used for the templates
  468.    CHAR         szBitmapPath[CCHMAXPATH];         // Last path used for the bitmaps
  469. #endif
  470.    CHAR         szBitmapSearchPath[MAXPATHL];     // Bitmap search path
  471.    CHAR         szDefaultBitmap[MAXPATHL];
  472. } UCMDATA, *PUCMDATA;
  473.  
  474. typedef struct _UCMINFO {
  475.    ULONG  cb;                   // size of this structure
  476.    HWND    hwndMenu;            // Menu window-handle
  477.    HMODULE hModule;             // Module where the bitmaps are
  478.    USHORT  NbOfCols;            // Number of Columns (used for a matrix UCM)
  479.    USHORT  NbOfRows;            // Number of Rows    (used for a matrix UCM)
  480.    PSZ     pszBitmapSearchPath; // Path(s) to search for bitmap files.
  481.                                 // Environment variables separated by spaces.
  482.    PSZ     pszDefaultBitmap;    // Bitmap to use if bitmap specified for
  483.                                 //  a menu item can't be resolved or loaded.
  484.    ULONG   Style;               // Style of item (combination of UCS_ flags )
  485.    ULONG   cx;                  // Size to give to all the items if UCS_FORCESIZE
  486.    ULONG   cy;                  //
  487.    LONG    BgBmp;               // RGB value of the color of the bmp which has to be replaced with ItemBgColor
  488.    LONG    BgColor;             // RGB color of the UCMenu background
  489.    LONG    ItemBgColor;         // RGB color of the UCMenu items background, used if UCS_CHNGBMPBG is set
  490.    PSZ     pszFontNameSize;     // String describing the font of the UCMenu (such as used
  491.    ULONG   ulTmplVersion;       //  in WinSetPresParam), if NULL, UCM_DEFAULTFONT is used
  492.    ULONG   BubbleDelay;         // Bubble-help delay (msec)
  493.    ULONG   BubbleRead;          // Bubble-help read time (msec)
  494.    HMODULE hModUCM;             // Module that we use...
  495. } UCMINFO2, *PUCMINFO2;
  496.  
  497. typedef struct _MTI {
  498.   USHORT afStyle;
  499.   USHORT afAttribute;
  500.   USHORT idItem;
  501.   CHAR   c[2];
  502. } MTI, *PMTI;
  503.  
  504. typedef struct _MENUTEMPLATE {
  505.   USHORT Length;
  506.   USHORT Version;
  507.   USHORT CodePage;
  508.   USHORT Offset;
  509.   USHORT Count;
  510.   CHAR   c[2];
  511. } MENUTEMPLATE, *PMENUTEMPLATE;
  512.  
  513. typedef struct _UCMDLGINFO {
  514.   ULONG    ulSize;
  515.   HWND     hwndUCMenu;
  516.   HWND     hwndBuffet;
  517.   ULONG    ulBuffetMenuID;
  518.   HMODULE  hmodBuffetMenu;
  519.   PVOID    pTemplate;
  520.   BOOL     bFromTemplate;
  521.   PFNWP    OldShredderWndProc;
  522.   PUCMDATA UCMData;
  523. } UCMDLGINFO, * PUCMDLGINFO;
  524.  
  525. //----------------------------------------------------------------------------
  526. // GpiQueryColorData in pmgpi.h but GpiQueryColordata in os2386.lib
  527. //----------------------------------------------------------------------------
  528. BOOL  APIENTRY GpiQueryColordata(HPS hps, LONG lCount, PLONG alArray);
  529.  
  530.  
  531.  
  532. //----------------------------------------------------------------------------
  533. // local function declarations
  534. //----------------------------------------------------------------------------
  535. MRESULT EXPENTRY          UCMenuWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  536. MRESULT EXPENTRY          ScrollbarProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  537. MRESULT EXPENTRY            HideWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  538. MRESULT EXPENTRY         SubmenuWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  539. MRESULT EXPENTRY            MenuWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  540. MRESULT EXPENTRY          BubbleWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  541. MRESULT EXPENTRY  UCMenuSettingsDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  542. MRESULT EXPENTRY      UCMenuNBP1DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  543. MRESULT EXPENTRY      UCMenuNBP2DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  544. MRESULT EXPENTRY      UCMenuNBP0DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  545. MRESULT EXPENTRY     UCMenuStyleDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  546. MRESULT EXPENTRY      BitmapFileDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  547. MRESULT EXPENTRY UCMenuCreateBmpDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  548. MRESULT EXPENTRY          ResBmpDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  549. MRESULT EXPENTRY             UCMDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  550. MRESULT EXPENTRY        ShredderWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  551. MRESULT _Optlink        UCMenuDrgDrpMsg(PUCMDATA UCMData, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, PFNWP WindowProc);
  552. VOID _Optlink  UCMenuRemoveDropEmphasis(PUCMDATA UCMdata, HWND hwnd );
  553. BOOL _Optlink     UCMenuCheckScrolling(HWND hwndUCMenu);
  554. BOOL _Optlink               UCMenuSize(HWND hwndMenu, USHORT Style);
  555. VOID _Optlink       UCMenuLoadMenuData(HWND hwndMenu, PUCMDATA UCMData, ULONG ulVersion, HWND hwndUCM );
  556. VOID _Optlink        UCMenuLoadItemBmp(MENUITEM *Item, PUCMDATA UCMData );
  557. VOID _Optlink       UCMenuCalcItemSize(POWNERITEM poi, USHORT Style, HWND hwndUCMenu, ULONG * pCx, ULONG * pCy);
  558. VOID _Optlink UCMenuCalcUnscaledItemSize(PUCMITEM pUCMI, USHORT Style, HWND hwndUCMenu, ULONG * pCx, ULONG * pCy);
  559. VOID _Optlink         UCMenuCalcBmpPos(POWNERITEM poi, HWND hwndUCM, USHORT Style, POINTL aptlPoints[4], PUCMDATA UCMData);
  560. VOID _Optlink       UCMenuCalcTextSize(PUCMITEM pUCMI, HWND hwndUCM, ULONG * pWidth, ULONG * pHeight);
  561. ULONG _Optlink       UCMenuSelectColor(LONG Color, HPS hps);
  562. VOID _Optlink      UCMenuSetBmpBgColor(PUCMITEM pUCMItem, PUCMDATA UCMData, HPS hps);
  563. VOID _Optlink            UCMenu3DFrame(HPS hps, PRECTL rcl, USHORT hilited);
  564. VOID _Optlink        UCMenuContextMenu(HWND hwndUCMenu, HWND hwndMenu, ULONG FromMouse);
  565. VOID   _Optlink           UCMenuNBP1OK(HWND hwnd);
  566. VOID   _Optlink           UCMenuNBP2OK(HWND hwnd);
  567. BOOL   _Optlink           UCMenuNBP0OK(HWND hwndPage);
  568. VOID   _Optlink       UCMenuStyleDlgOK(HWND hwnd);
  569. VOID   _Optlink       UCMenuUpdateMenu(HWND hwndMenu, BOOL UpdateSubmenus);
  570. VOID    _Optlink      UCMenuUnselectAll(HWND hwndMenu);
  571. USHORT  _Optlink         UCMenuGetNewID(HWND hwndMenu, SHORT sID, PUCMDATA UCMData);
  572. VOID    _Optlink      UCMenuReplaceMenu(HWND hwndOldMenu, HWND hwndNewMenu);
  573. BOOL    _Optlink         UCMenuInitDrag(HWND hwnd, SHORT x, SHORT y);
  574. MRESULT _Optlink         UCMenuDragOver(PUCMDATA UCMData, HWND hwnd, PDRAGINFO pDragInfo);
  575. VOID    _Optlink             UCMenuDrop(HWND hwnd, PDRAGINFO pDraginfo);
  576. VOID    _Optlink UCMenuPresParamChanged(PUCMDATA UCMData, HWND hwnd, MPARAM mp1);
  577. PSZ     _Optlink       UCMenuGetExePath(VOID);
  578. USHORT  _Optlink    UCMenuGetBitmapPath(PUCMDATA UCMDATA, PSZ pszBmp, PSZ pszPathName);
  579. USHORT _Optlink UCMenuGetBitmapFullName(PUCMDATA UCMDATA, PSZ pszBmp, PSZ pszFullName);
  580. VOID    _Optlink         GetMaxItemSize(PUCMDATA UCMData, HWND hwndUCMenu, HWND hwndMenu);
  581. VOID    _Optlink   UCMenuNBP0Initialize(PUCMDATA UCMData, HWND hwnd);
  582. VOID    _Optlink   UCMenuNBP1Initialize(PUCMDATA UCMData, HWND hwnd);
  583. VOID    _Optlink   UCMenuNBP2Initialize(PUCMDATA UCMData, HWND hwnd);
  584. VOID    _Optlink      UCMenuEditBmpFile(HWND hwndNBP1, PSZ pszBmpFileName);
  585. VOID    _System     UCMenuEditBmpFileT2(PVOID pArgs);
  586. BOOL    _Optlink    UCMenuCreateBmpFile(PSZ pszBmpFileName, ULONG cx, ULONG cy);
  587. VOID    _Optlink    UCMenuNBP1UpdateBmp(HWND hwnd, PSZ pszFileName);
  588. VOID    _Optlink    UCMenuDisplayHelp(PUCMDATA UCMData, USHORT usPanelID, USHORT usCustomID);
  589. VOID    _Optlink     InitializeStyleDlg(PUCMDATA UCMData, HWND hwnd);
  590. BOOL    _Optlink         TranslateAccel(PUCMDATA UCMData, HWND HwndMenu, USHORT Key, PQMSG QMsg);
  591. VOID    _Optlink           AddAccelItem(PUCMDATA UCMData, USHORT Key, ULONG id);
  592. VOID    _Optlink        RemoveAccelItem(PUCMDATA UCMData, USHORT Key);
  593. PSZ     _Optlink           SubMemStrdup(PVOID pSubMem, PSZ pszSource);
  594. PSZ     _Optlink          nlsgetmessage(HAB Hab, HMODULE HModule, SHORT msg, SHORT buffnum);
  595. PVOID   _Optlink    UCMenuMakeTemplate2(HWND hwndMenu, PVOID pBuf, USHORT MenuAttr);
  596. ULONG   _Optlink      UCMenuTemplateLen(HWND hwndMenu);
  597. HWND    _Optlink           UCMenuCreate(HAB hab, HWND hParent, HWND hOwner, ULONG ulStyle,
  598.                                         LONG x, LONG y, LONG cx, LONG cy, HWND hInsertBehind,
  599.                                         ULONG ulID, PUCMINFO2 pUCMInfo2);
  600. VOID    _System    UCMenuExecuteProgram(PSZ pszName);
  601. SHORT   _Optlink     UCMenuGetActionID2(HWND hwndMenu, PSZ pszAction, BOOL bSubmenus, SHORT sStartID);
  602. VOID    _System        UCMenuLoadResBmp(PVOID pArgs);
  603. VOID    _Optlink         UCMenuNotifAll(PUCMDATA UCMData, HWND hMenu, USHORT usNotif);
  604. BOOL    _Optlink    UCAdjacentItemBlank(HWND MenuHwnd, SHORT ItemID, int LeftRight);
  605. void    _Optlink UCMenuCreateBubbleWindow(HWND UCMenuHwnd, UCMDATA *UCMData);
  606. LONG    _Optlink UCMString2Int(char *lpString, BOOL *lpTranslated);
  607.  
  608. //----------------------------------------------------------------------------
  609. // UCMenuCreateFromResource
  610. //----------------------------------------------------------------------------
  611. // :function res=&IDF_UCMCREATERES. name='UCMenuCreateFromResource' text='Create a ucmenu from a resource menu'.
  612. // This function creates a ucmenu using a menu template stored in the resources.
  613. // :syntax name='UCMenuCreateFromResource' params='hab hParent hOwner ulStyle x y cx cy hInsertBehind ulID hmodResource usMenuID pUCMInfo phTextMenu' return='hUCMenu' .
  614. // :fparams.
  615. // :fparam name='hab' type='HAB' io='input' .
  616. // Handle of the anchor-block.
  617. // :fparam name='hParent' type='HWND' io='input' .
  618. // Handle of the parent window
  619. // :fparam name='hOwner' type='HWND' io='input' .
  620. // Handle of the owner window
  621. // :fparam name='flStyle' type='ULONG' io='input' .
  622. // Style flags of the ucmenu window, combination of WS_ flags and CMS_VERT CMS_HORZ or CMS_MATRIX
  623. // :fparam name='x' type='ULONG' io='input'.
  624. // x coordinate of ucmenu window position
  625. // :fparam name='y' type='ULONG' io='input'.
  626. // y coordinate of ucmenu window position
  627. // :fparam name='cx' type='ULONG' io='input'.
  628. // width of the ucmenu window, ignored if vertical or matrix ucmenu
  629. // :fparam name='cy' type='ULONG' io='input'.
  630. // height of the ucmenu window, ignored if horizontal or matrix ucmenu
  631. // :fparam name='hInsertBehind' type='ULONG' io='input'.
  632. // Sibling window behind which the ucmenu is placed, can also be HWND_TOP or HWND_BOTTOM.
  633. // :fparam name='ulID' type='ULONG' io='input'.
  634. // ID given to the ucmenu.
  635. // :fparam name='hmodResource' type='HMODULE' io='input'.
  636. // Handle of the module where the menu resource is to be found.
  637. // :fparam name='usMenuID' type='USHORT' io='input'.
  638. // ID of the resource menu used as a template to create the ucmenu.
  639. // :fparam name='pUCMInfo' type='PUCMINFO' io='input'.
  640. // Pointer to the ucmenu creation structure
  641. // :fparam name='phTextMenu' type='PHWND' io='output'.
  642. // Handle of the menu loaded from the resource.
  643. // It should normally not be used.
  644. // :freturns.
  645. // :fparam name='hUCMenu' type='PSZ' io='return'.
  646. // Handle of the ucmenu or zero if the creation failed.
  647. // :efparams.
  648. // :remarks.
  649. // :related.
  650. // UCMInfo
  651. // :efunction.
  652. //----------------------------------------------------------------------------
  653. HWND    APIENTRY UCMenuCreateFromResource(HAB hab, HWND hParent, HWND hOwner,
  654.                                           ULONG ulStyle, LONG x, LONG y, LONG cx, LONG cy,
  655.                                           HWND hInsertBehind, ULONG ulID,
  656.                                           HMODULE hmodResource, USHORT usMenuID,
  657.                                           PUCMINFO pUCMInfo, PHWND phTextMenu )
  658. {
  659.    HWND     hMenu;
  660.    ERRORID  err;
  661.  
  662.    hMenu = WinLoadMenu( HWND_OBJECT, hmodResource, usMenuID );
  663.  
  664.    if ( hMenu ){
  665.       UCMINFO2 UCMInfo2;
  666.  
  667.       WinSetWindowUShort( hMenu, QWS_ID, (USHORT)ulID );
  668.  
  669.       UCMInfo2.cb = sizeof( UCMINFO2 );
  670.       UCMInfo2.hwndMenu = hMenu;
  671.       UCMInfo2.hModule              = pUCMInfo->hModule;
  672.       UCMInfo2.NbOfCols             = pUCMInfo->NbOfCols;
  673.       UCMInfo2.NbOfRows             = pUCMInfo->NbOfRows;
  674.       UCMInfo2.pszBitmapSearchPath  = pUCMInfo->pszBitmapSearchPath;
  675.       UCMInfo2.pszDefaultBitmap     = pUCMInfo->pszDefaultBitmap;
  676.       UCMInfo2.Style                = pUCMInfo->Style;
  677.       UCMInfo2.cx                   = pUCMInfo->cx;
  678.       UCMInfo2.cy                   = pUCMInfo->cy;
  679.       UCMInfo2.BgBmp                = pUCMInfo->BgBmp;
  680.       UCMInfo2.BgColor              = pUCMInfo->BgColor;
  681.       UCMInfo2.ItemBgColor          = pUCMInfo->ItemBgColor;
  682.       UCMInfo2.pszFontNameSize      = pUCMInfo->pszFontNameSize;
  683.       UCMInfo2.BubbleDelay          = pUCMInfo->BubbleDelay;  // V2.04 
  684.       UCMInfo2.BubbleRead           = pUCMInfo->BubbleRead;   // V2.04
  685.       UCMInfo2.hModUCM              = pUCMInfo->hModUCM;      // V2.04 
  686.       UCMInfo2.ulTmplVersion        = UCMTMPLVERSION;
  687.  
  688.       *phTextMenu = hMenu;
  689.       return UCMenuCreate( hab, hParent,  hOwner, ulStyle, x, y, cx, cy,
  690.                            hInsertBehind, ulID, &UCMInfo2 );
  691.    } else {
  692.       return NULLHANDLE;
  693.    } // endif
  694.  
  695. }
  696.  
  697. //----------------------------------------------------------------------------
  698. // UCMenuCreateFromHMenu
  699. //----------------------------------------------------------------------------
  700. // :function res=&IDF_UCMCREATEHMENU. name='UCMenuCreateFromHMenu' text='Create a ucmenu from a menu handle'.
  701. // This function creates a ucmenu using an already loaded or created menu.
  702. // :syntax name='UCMenuCreateFromHMenu' params='hab hParent hOwner ulStyle x y cx cy hInsertBehind ulID  hMenu pUCMInfo' return='hUCMenu'.
  703. // :fparams.
  704. // :fparam name='hab' type='HAB' io='input' .
  705. // Handle of the anchor-block.
  706. // :fparam name='hParent' type='HWND' io='input' .
  707. // Handle of the parent window
  708. // :fparam name='hOwner' type='HWND' io='input' .
  709. // Handle of the owner window
  710. // :fparam name='flStyle' type='ULONG' io='input' .
  711. // Style flags of the ucmenu window, combination of WS_ flags and CMS_VERT CMS_HORZ or CMS_MATRIX
  712. // :fparam name='x' type='ULONG' io='input'.
  713. // x coordinate of ucmenu window position
  714. // :fparam name='y' type='ULONG' io='input'.
  715. // y coordinate of ucmenu window position
  716. // :fparam name='cx' type='ULONG' io='input'.
  717. // width of the ucmenu window, ignored if vertical or matrix ucmenu
  718. // :fparam name='cy' type='ULONG' io='input'.
  719. // height of the ucmenu window, ignored if horizontal or matrix ucmenu
  720. // :fparam name='hInsertBehind' type='ULONG' io='input'.
  721. // Sibling window behind which the ucmenu is placed, can also be HWND_TOP or HWND_BOTTOM.
  722. // :fparam name='ulID' type='ULONG' io='input'.
  723. // ID given to the ucmenu.
  724. // :fparam name='hMenu' type='HWND' io='input'.
  725. // Handle of the menu used as a template to create the ucmenu
  726. // :fparam name='pUCMInfo' type='PUCMINFO' io='input'.
  727. // Pointer to the ucmenu creation structure
  728. // :freturns.
  729. // :fparam name='hUCMenu' type='PSZ' io='return'.
  730. // Handle of the ucmenu or zero if the creation failed.
  731. // :efparams.
  732. // :remarks.
  733. // It is useful in case you want to create a void ucmenu and dynamically fill it.
  734. // :related.
  735. // UCMInfo
  736. // :efunction.
  737. //----------------------------------------------------------------------------
  738. HWND    APIENTRY UCMenuCreateFromHMenu( HAB hab, HWND hParent, HWND hOwner,
  739.                                         ULONG ulStyle, LONG x, LONG y, LONG cx, LONG cy,
  740.                                         HWND hInsertBehind, ULONG ulID,
  741.                                         HWND hMenu, PUCMINFO pUCMInfo )
  742. {
  743.    if ( hMenu ){
  744.       UCMINFO2 UCMInfo2;
  745.  
  746.       UCMInfo2.cb = sizeof( UCMINFO2 );
  747.       UCMInfo2.hwndMenu = hMenu;
  748.       UCMInfo2.hModule              = pUCMInfo->hModule;
  749.       UCMInfo2.NbOfCols             = pUCMInfo->NbOfCols;
  750.       UCMInfo2.NbOfRows             = pUCMInfo->NbOfRows;
  751.       UCMInfo2.pszBitmapSearchPath  = pUCMInfo->pszBitmapSearchPath;
  752.       UCMInfo2.pszDefaultBitmap     = pUCMInfo->pszDefaultBitmap;
  753.       UCMInfo2.Style                = pUCMInfo->Style;
  754.       UCMInfo2.cx                   = pUCMInfo->cx;
  755.       UCMInfo2.cy                   = pUCMInfo->cy;
  756.       UCMInfo2.BgBmp                = pUCMInfo->BgBmp;
  757.       UCMInfo2.BgColor              = pUCMInfo->BgColor;
  758.       UCMInfo2.ItemBgColor          = pUCMInfo->ItemBgColor;
  759.       UCMInfo2.pszFontNameSize      = pUCMInfo->pszFontNameSize;
  760.       UCMInfo2.BubbleDelay          = pUCMInfo->BubbleDelay;  // V2.04 
  761.       UCMInfo2.BubbleRead           = pUCMInfo->BubbleRead;   // V2.04
  762.       UCMInfo2.hModUCM              = pUCMInfo->hModUCM;      // V2.04 
  763.       UCMInfo2.ulTmplVersion        = UCMTMPLVERSION;
  764.       return UCMenuCreate( hab, hParent,  hOwner, ulStyle, x, y, cx, cy,
  765.                            hInsertBehind, ulID, &UCMInfo2 );
  766.    } else {
  767.       return NULLHANDLE;
  768.    } // endif
  769.  
  770. }
  771.  
  772.  
  773. //----------------------------------------------------------------------------
  774. // UCMenuCreateFromTemplate
  775. //----------------------------------------------------------------------------
  776. // :function res=&IDF_UCMCREATETMPL. name='UCMenuCreateFromTemplate' text='Create a ucmenu from a menu template'.
  777. // This function creates a ucmenu using a menu template stored in the resources.
  778. // :syntax name='UCMenuCreateFromTemplate' params='hab hParent hOwner ulStyle x y cx cy hInsertBehind ulID pMenuTemplate pUCMInfo phTextMenu' return='hUCMenu' .
  779. // :fparams.
  780. // :fparam name='hab' type='HAB' io='input' .
  781. // Handle of the anchor-block.
  782. // :fparam name='hParent' type='HWND' io='input' .
  783. // Handle of the parent window
  784. // :fparam name='hOwner' type='HWND' io='input' .
  785. // Handle of the owner window
  786. // :fparam name='flStyle' type='ULONG' io='input' .
  787. // Style flags of the ucmenu window, combination of WS_ flags and CMS_VERT CMS_HORZ or CMS_MATRIX
  788. // :fparam name='x' type='ULONG' io='input'.
  789. // x coordinate of ucmenu window position
  790. // :fparam name='y' type='ULONG' io='input'.
  791. // y coordinate of ucmenu window position
  792. // :fparam name='cx' type='ULONG' io='input'.
  793. // width of the ucmenu window, ignored if vertical or matrix ucmenu
  794. // :fparam name='cy' type='ULONG' io='input'.
  795. // height of the ucmenu window, ignored if horizontal or matrix ucmenu
  796. // :fparam name='hInsertBehind' type='ULONG' io='input'.
  797. // Sibling window behind which the ucmenu is placed, can also be HWND_TOP or HWND_BOTTOM.
  798. // :fparam name='ulID' type='ULONG' io='input'.
  799. // ID given to the ucmenu.
  800. // :fparam name='pmtMenuTemplate' type='PVOID' io='input'.
  801. // Pointer to the menu template in binary format
  802. // :fparam name='pUCMInfo' type='PUCMINFO' io='input'.
  803. // Pointer to the ucmenu creation structure
  804. // :fparam name='phTextMenu' type='PHWND' io='output'.
  805. // Handle of the menu loaded from the resource.
  806. // It should normally not be used.
  807. // :freturns.
  808. // :fparam name='hUCMenu' type='PSZ' io='return'.
  809. // Handle of the ucmenu or zero if the creation failed.
  810. // :efparams.
  811. // :remarks.
  812. // :related.
  813. // UCMInfo
  814. // :efunction.
  815. //----------------------------------------------------------------------------
  816. HWND    APIENTRY UCMenuCreateFromTemplate(HAB hab, HWND hParent, HWND hOwner,
  817.                                           ULONG ulStyle, LONG x, LONG y, LONG cx, LONG cy,
  818.                                           HWND hInsertBehind, ULONG ulID,
  819.                                           PVOID pmtMenuTemplate,
  820.                                           PUCMINFO pUCMInfo, PHWND phTextMenu )
  821. {
  822.    HWND     hMenu;
  823.    UCMINFO2 UCMInfo2;
  824.  
  825.  
  826.    if ( *( (PULONG)pmtMenuTemplate ) == UCMTMPLSIG ){
  827.       UCMInfo2.ulTmplVersion = *( (PULONG)( (PBYTE)pmtMenuTemplate + 4 ) );
  828.       hMenu = WinCreateMenu( HWND_OBJECT, (PVOID)((PBYTE)pmtMenuTemplate+8) );
  829.    } else {
  830. //      UCMInfo2.ulTmplVersion = 0;
  831. //      hMenu = WinCreateMenu( HWND_OBJECT, pmtMenuTemplate );
  832.       return NULLHANDLE;
  833.    } // endif
  834.  
  835.    if ( hMenu ){
  836.  
  837.       WinSetWindowUShort( hMenu, QWS_ID, (USHORT)ulID );
  838.  
  839.       UCMInfo2.cb = sizeof( UCMINFO2 );
  840.       UCMInfo2.hwndMenu = hMenu;
  841.       UCMInfo2.hModule              = pUCMInfo->hModule;
  842.       UCMInfo2.NbOfCols             = pUCMInfo->NbOfCols;
  843.       UCMInfo2.NbOfRows             = pUCMInfo->NbOfRows;
  844.       UCMInfo2.pszBitmapSearchPath  = pUCMInfo->pszBitmapSearchPath;
  845.       UCMInfo2.pszDefaultBitmap     = pUCMInfo->pszDefaultBitmap;
  846.       UCMInfo2.Style                = pUCMInfo->Style;
  847.       UCMInfo2.cx                   = pUCMInfo->cx;
  848.       UCMInfo2.cy                   = pUCMInfo->cy;
  849.       UCMInfo2.BgBmp                = pUCMInfo->BgBmp;
  850.       UCMInfo2.BgColor              = pUCMInfo->BgColor;
  851.       UCMInfo2.ItemBgColor          = pUCMInfo->ItemBgColor;
  852.       UCMInfo2.pszFontNameSize      = pUCMInfo->pszFontNameSize;
  853.       UCMInfo2.BubbleDelay          = pUCMInfo->BubbleDelay;  // V2.04 
  854.       UCMInfo2.BubbleRead           = pUCMInfo->BubbleRead;   // V2.04
  855.       UCMInfo2.hModUCM              = pUCMInfo->hModUCM;      // V2.04 
  856.       *phTextMenu = hMenu;
  857.       return UCMenuCreate( hab, hParent,  hOwner, ulStyle, x, y, cx, cy,
  858.                            hInsertBehind, ulID, &UCMInfo2 );
  859.    } else {
  860.       return NULLHANDLE;
  861.    } // endif
  862.  
  863. }
  864.  
  865. //----------------------------------------------------------------------------
  866. // UCMenuCreate
  867. //----------------------------------------------------------------------------
  868. // :pfunction res=&IDF_UCMCREATE. name='UCMenuCreate' text='Create a ucmenu from a menu'.
  869. // This function creates a ucmenu using a menu already loaded.
  870. // :syntax name='UCMenuCreateFromTemplate' params='hab hParent hOwner ulStyle x y cx cy hInsertBehind ulID pUCMInfo2 ' return='hUCMenu' .
  871. // :fparams.
  872. // :fparam name='hab' type='HAB' io='input' .
  873. // Handle of the anchor-block.
  874. // :fparam name='hParent' type='HWND' io='input' .
  875. // Handle of the parent window
  876. // :fparam name='hOwner' type='HWND' io='input' .
  877. // Handle of the owner window
  878. // :fparam name='flStyle' type='ULONG' io='input' .
  879. // Style flags of the ucmenu window, combination of WS_ flags and CMS_VERT CMS_HORZ or CMS_MATRIX
  880. // :fparam name='x' type='ULONG' io='input'.
  881. // x coordinate of ucmenu window position
  882. // :fparam name='y' type='ULONG' io='input'.
  883. // y coordinate of ucmenu window position
  884. // :fparam name='cx' type='ULONG' io='input'.
  885. // width of the ucmenu window, ignored if vertical or matrix ucmenu
  886. // :fparam name='cy' type='ULONG' io='input'.
  887. // height of the ucmenu window, ignored if horizontal or matrix ucmenu
  888. // :fparam name='hInsertBehind' type='ULONG' io='input'.
  889. // Sibling window behind which the ucmenu is placed, can also be HWND_TOP or HWND_BOTTOM.
  890. // :fparam name='ulID' type='ULONG' io='input'.
  891. // ID given to the ucmenu.
  892. // :fparam name='pUCMInfo2' type='PUCMINFO2' io='input'.
  893. // Pointer to the ucmenu creation structure
  894. // :freturns.
  895. // :fparam name='hUCMenu' type='PSZ' io='return'.
  896. // Handle of the ucmenu or zero if the creation failed.
  897. // :efparams.
  898. // :remarks.
  899. // :related.
  900. // :epfunction.
  901. //----------------------------------------------------------------------------
  902. HWND    _Optlink UCMenuCreate( HAB hab, HWND hParent, HWND hOwner,
  903.                                ULONG ulStyle, LONG x, LONG y, LONG cx, LONG cy,
  904.                                HWND hInsertBehind, ULONG ulID,
  905.                                PUCMINFO2 pUCMInfo2 )
  906. {
  907.  
  908.  
  909.  /* Register UCMenu class with storage for 2 pointers */
  910.  
  911.  /* (MAM) Note we must always register the class, even if it already */
  912.  /* exists.  Otherwise an app might free and reload the UCMenus DLL  */
  913.  /* in the same process and the class window proc pointer would be   */
  914.  /* out of date.  Reregistration will replace existing class parms.  */
  915.  
  916.  if ( !WinRegisterClass( hab, UCMCLASS, (PFNWP)UCMenuWndProc, (ULONG)CS_SIZEREDRAW, (ULONG)(2*sizeof(PVOID)) ) ) {
  917.     return NULLHANDLE;
  918.  } // endif
  919.  
  920.  return  WinCreateWindow( hParent,
  921.                           UCMCLASS,
  922.                           "",
  923.                           ulStyle,
  924.                           x,
  925.                           y,
  926.                           cx,
  927.                           cy,
  928.                           hOwner,
  929.                           hInsertBehind,
  930.                           ulID,
  931.                           (PVOID)pUCMInfo2,
  932.                           NULL );
  933.  
  934. }
  935.  
  936. //----------------------------------------------------------------------------
  937. // UCMenuLoadBitmap
  938. //----------------------------------------------------------------------------
  939. // :function res=&IDF_LOADBIT. name='UCMenuLoadBitmap' text='Loads a bitmap'.
  940. // This function loads a bitmap from a file and returns its handle.
  941. // :syntax name='UCMenuLoadBitmap' params='pszFileName' return='hBitmap' .
  942. // :fparams.
  943. // :fparam name='pszFileName' type='PSZ' io='input' .
  944. // Name of the file to load.
  945. // :freturns.
  946. // :fparam name='hBitmap' type='LONG' io='return'.
  947. // Bit-map handle (0 if error)
  948. // :efparams.
  949. // :remarks.
  950. // If there is an array of bitmaps, the bitmap the most appropriate to the
  951. // current display will be chosen.
  952. // :related.
  953. // :efunction.
  954. //----------------------------------------------------------------------------
  955. LONG APIENTRY    UCMenuLoadBitmap(PSZ pszFileName)
  956. {
  957.   HBITMAP                 hBmp = 0;
  958.   FILEHANDLE              File;
  959.   ULONG                   rc;
  960.   USHORT                  usType = 0;           // #@!!! compiler warnings
  961.   PBITMAPARRAYFILEHEADER2 pbafh2 = NULL;        // (MAM) chng init values to NULL instead of ptr to 0
  962.   PBITMAPFILEHEADER2      pbfh2  = NULL;                       
  963.   PBITMAPINFOHEADER2      pbih2  = NULL;                       
  964.   PBITMAPINFO2            pbmi2  = NULL;                       
  965.   PBITMAPARRAYFILEHEADER  pbafh  = NULL;                       
  966.   PBITMAPFILEHEADER       pbfh   = NULL;                       
  967.   PBITMAPINFOHEADER       pbih   = NULL;                       
  968.   BOOL                    f2;        // format 1.x or 2.x
  969.   ULONG                   ulOffset;
  970.   PBYTE                   pData  = NULL;
  971.   ULONG                   ulDataSize;
  972.   SIZEL                   sizel;
  973.   HPS                     hPS = WinGetPS(HWND_DESKTOP);
  974.  
  975.   /* If this is not a .BMP file, let PM try to extract an icon from it */
  976.   //...removed because bitmaps made from icons have black backgrounds
  977.   //...unless you do a lot more work to mask the background bits.
  978. //{
  979. //  char *BmpFn;
  980. //  BmpFn = strdup(pszFileName);
  981. //  AnsiUpperBuff(BmpFn, strlen(BmpFn));
  982. //  if (strstr(BmpFn, ".BMP")==NULL) {
  983. //    HPOINTER Icon;
  984. //    POINTERINFO IconInfo;
  985. //    HBITMAP  IconBmp = 0;
  986. //
  987. //    free(BmpFn);
  988. //    Icon = WinLoadFileIcon(pszFileName, TRUE);
  989. //    if (Icon != 0) {
  990. //      if (WinQueryPointerInfo(Icon, &IconInfo)) {
  991. //        if ((IconInfo.hbmPointer!=0) && (IconInfo.hbmColor!=0)) {
  992. //          IconBmp = IconInfo.hbmColor;
  993. //          //...what we should do here to get a good bitmap from a file, is
  994. //          //...use the hbmPointer bitmap (which is a 2X high monochrome bitmap
  995. //          //...consisting of and AND mask and an XOR mask) and the hbmColor
  996. //          //...bitmap and create a new bitmap that has the background bits set
  997. //          //...to the background color.  The black pixels of the AND mask indicate
  998. //          //...background pixels of the color bitmap.
  999. //          //...Hummm... maybe can use WinDrawPointer() to do all this for us,
  1000. //          //...and draw into a bitmap which is pre-filled w/the background color?
  1001. //        }
  1002. //        WinFreeFileIcon(Icon);
  1003. //      }
  1004. //    }
  1005. //
  1006. //    return IconBmp; // Return file bitmap if we found it
  1007. //  }
  1008. //  free(BmpFn);
  1009. //}
  1010.  
  1011.   //--- open the file
  1012.   File = OPENREAD(pszFileName);
  1013.   if (File == NULLFILE) goto ExitLoadBMP;
  1014.  
  1015.   /* Read image type, and reset the stream...................................*/
  1016.   /* The image type is a USHORT, so we only read that........................*/
  1017.   rc = READFILE(&usType, 1, sizeof(usType), File);
  1018.   if (rc != sizeof(usType)) goto ExitLoadBMP;
  1019.  
  1020.  
  1021.   /* Next read the bitmap info header........................................*/
  1022.   // we allocate enough to hold a complete bitmap array file header
  1023.   pbafh2 = (PBITMAPARRAYFILEHEADER2)MyMalloc(sizeof(*pbafh2)+256*sizeof(RGB2));
  1024.   if (!pbafh2) goto ExitLoadBMP;
  1025.   /* Next we assign pointers to the file header and bitmap info header...*/
  1026.   /* Both the 1.x and 2.x structures are assigned just in case...........*/
  1027.   pbfh2 = &pbafh2->bfh2;
  1028.   pbih2 = &pbfh2->bmp2;
  1029.   pbmi2 = (PBITMAPINFO2)pbih2;
  1030.   pbafh = (PBITMAPARRAYFILEHEADER)pbafh2;
  1031.   pbfh  = &pbafh->bfh;
  1032.   pbih  = &pbfh->bmp;
  1033.   switch (usType) {
  1034.     case BFT_BMAP:
  1035.     case BFT_ICON:
  1036.     case BFT_POINTER:
  1037.     case BFT_COLORICON:
  1038.     case BFT_COLORPOINTER: {
  1039.       /* Now we assume the image is a 2.0 image and so we read a bitmap-file-*/
  1040.       /* Now we reset the stream, next we'll read the bitmap info header. To do .*/
  1041.       /* this we need to reset the stream to 0...................................*/
  1042.       rc = fseek(File, 0, SEEK_SET);
  1043.       if (!SEEKOK(rc)) goto ExitLoadBMP;
  1044.       /*-header-2 structure..................................................*/
  1045.       rc = READFILE(pbfh2, 1, sizeof(*pbfh2), File);
  1046.       if (rc != sizeof(*pbfh2)) goto ExitLoadBMP;
  1047.  
  1048.       f2 = pbih2->cbFix > sizeof(*pbih); // 1.x or 2.x bitmap
  1049.       /* We will need to read the color table. Thus we position the stream...*/
  1050.       /* so that the next read will read IT. This, of course, depends on the.*/
  1051.       /* type of the bitmap (old vs new), note that in the NEW case, we can..*/
  1052.       /* not be certain of the size of the bitmap header.....................*/
  1053.       ulOffset = (f2) ? sizeof(*pbfh2) + pbih->cbFix - sizeof(*pbih2):
  1054.                         sizeof(*pbfh);
  1055.     } break;
  1056.  
  1057.     case BFT_BITMAPARRAY: {
  1058.       /* Now we are dealing with a bitmap array. This is a collection of ....*/
  1059.       /* bitmap files and each has its own file header.......................*/
  1060.       BOOL   bBest = FALSE;
  1061.       ULONG  ulCurOffset, ulOffsetTemp = 0;
  1062.       LONG   lScreenWidth;
  1063.       LONG   lScreenHeight;
  1064.       LONG   lClrsDev, lClrsTemp = 0;
  1065.       LONG   lClrs;
  1066.       ULONG  ulSizeDiff, ulSizeDiffTemp = 0xffffffff;
  1067.       HDC    hdc;
  1068.  
  1069.       // -- We will browse through the array and chose the bitmap best suited
  1070.       // -- for the current display size and color capacities.
  1071.       hdc = GpiQueryDevice( hPS );
  1072.       DevQueryCaps( hdc, CAPS_COLORS, 1, &lClrsDev );
  1073.       DevQueryCaps( hdc, CAPS_WIDTH,  1, &lScreenWidth );
  1074.       DevQueryCaps( hdc, CAPS_HEIGHT, 1, &lScreenHeight );
  1075.       pbafh2->offNext = 0;
  1076.       do {
  1077.          ulCurOffset = pbafh2->offNext;
  1078.          rc = fseek( File, pbafh2->offNext, SEEK_SET );
  1079.          if ( !SEEKOK(rc) ){
  1080.             goto ExitLoadBMP;
  1081.          } // endif
  1082.          rc = READFILE( pbafh2, 1, sizeof(*pbafh2), File );
  1083.          if ( rc != sizeof(*pbafh2) ){
  1084.             goto ExitLoadBMP;
  1085.          } // endif
  1086.          f2 = pbih2->cbFix > sizeof(*pbih);
  1087.          if ( f2 ){
  1088.           lClrs = 1 << ( pbafh2->bfh2.bmp2.cBitCount * pbafh2->bfh2.bmp2.cPlanes);
  1089.          } else {
  1090.           lClrs = 1 << ( pbafh->bfh.bmp.cBitCount * pbafh->bfh.bmp.cPlanes);
  1091.          } //endif
  1092.          if ( ( pbafh2->cxDisplay == 0 ) && ( pbafh2->cyDisplay == 0 ) ) {
  1093.             // This is a device independant bitmap
  1094.             // Process it as a VGA
  1095.             pbafh2->cxDisplay = 640;
  1096.             pbafh2->cyDisplay = 480;
  1097.          } // endif
  1098.          ulSizeDiff = abs( pbafh2->cxDisplay - lScreenWidth ) + abs( pbafh2->cyDisplay - lScreenHeight );
  1099.          if ( ( lClrsDev == lClrs ) &&
  1100.               ( ulSizeDiff == 0 ) ){
  1101.             // We found the perfect match
  1102.             bBest = TRUE;
  1103.             ulOffsetTemp = ulCurOffset;
  1104.          } else {
  1105.             if (    ( ulOffsetTemp == 0 )                                // First time thru
  1106.                  || ( ulSizeDiff < ulSizeDiffTemp )                      // Better fit than any previous
  1107.                  || ( ( lClrs > lClrsTemp ) && ( lClrs < lClrsDev ) )    // More colors than prev & less than device
  1108.                  || ( ( lClrs < lClrsTemp ) && ( lClrs > lClrsDev ) ) ){
  1109.               ulOffsetTemp = ulCurOffset;                                // Make this our current pick
  1110.               lClrsTemp   = lClrs;
  1111.               ulSizeDiffTemp = ulSizeDiff;
  1112.            } // endif
  1113.          } // endif
  1114.       } while ( ( pbafh2->offNext != 0 ) && !bBest ); // enddo
  1115.  
  1116.       // Now retrieve the best bitmap
  1117.       rc = fseek( File, ulOffsetTemp, SEEK_SET );
  1118.       if ( !SEEKOK(rc) ){
  1119.          goto ExitLoadBMP;
  1120.       } // endif
  1121.       rc = READFILE( pbafh2, 1, sizeof(*pbafh2), File );
  1122.       if ( rc != sizeof(*pbafh2) ){
  1123.          goto ExitLoadBMP;
  1124.       } // endif
  1125.  
  1126.       f2 = pbih2->cbFix > sizeof(*pbih);
  1127.       /* as before, we calculate where to position the stream in order to ...*/
  1128.       /* read the color table information....................................*/
  1129.       ulOffset = ulOffsetTemp;
  1130.       ulOffset += (f2) ? sizeof(*pbafh2) + pbih2->cbFix - sizeof(*pbih2):
  1131.                          sizeof(*pbafh);
  1132.     } break;
  1133.  
  1134.    default:
  1135.      goto ExitLoadBMP;
  1136.   } /* endswitch */
  1137.   /* We now position the stream on the color table information...............*/
  1138.   rc = fseek(File, ulOffset, SEEK_SET);
  1139.   if (!SEEKOK(rc)) goto ExitLoadBMP;
  1140.  
  1141.   /* Read the color table....................................................*/
  1142.   if (f2) {
  1143.     /* For a 2.0 bitmap, all we need to do is read the color table...........*/
  1144.     /* The bitmap info structure is just the header + color table............*/
  1145.     // If we have 24 bits per pel, there is usually no color table, unless
  1146.     // pbih2->cclrUsed or pbih2->cclrImportant are non zero, we should
  1147.     // test that !
  1148.     if ( pbih2->cBitCount <24 ) {
  1149.        ULONG ul = (1 << pbih2->cBitCount) * sizeof(RGB2);
  1150.        rc = READFILE(&pbmi2->argbColor[0], 1, ul, File);
  1151.        if (rc != ul) goto ExitLoadBMP;
  1152.     } // endif
  1153.     /* remember the bitmap info we mentioned just above?.....................*/
  1154.     pbmi2 = (PBITMAPINFO2)pbih2;
  1155.   } else {
  1156.     /* This is an old format bitmap. Since the common format is the 2.0......*/
  1157.     /* We have to convert all the RGB entries to RGB2........................*/
  1158.     ULONG ul, cColors;
  1159.     RGB   rgb;
  1160.     if (pbih->cBitCount <24)
  1161.       cColors = 1 << pbih->cBitCount;
  1162.     else
  1163.     // If there are 24 bits per pel, the 24 bits are assumed to be a RGB value
  1164.       cColors = 0;
  1165.     /* Loop over the original table and create the new table, the extra byte.*/
  1166.     /* has to be 0...........................................................*/
  1167.     for (ul = 0; ul < cColors; ul++) {
  1168.       READFILE(&rgb, 1, sizeof(rgb), File);
  1169.       pbmi2->argbColor[ul].bRed      = rgb.bRed;
  1170.       pbmi2->argbColor[ul].bGreen    = rgb.bGreen;
  1171.       pbmi2->argbColor[ul].bBlue     = rgb.bBlue;
  1172.       pbmi2->argbColor[ul].fcOptions = 0;
  1173.     } /* endfor */
  1174.  
  1175.     // we have to convert the old to the new version header
  1176.     pbmi2->cbFix = sizeof(*pbih2);
  1177.     pbmi2->cBitCount = pbih->cBitCount;
  1178.     pbmi2->cPlanes = pbih->cPlanes;
  1179.     pbmi2->cy = pbih->cy;
  1180.     pbmi2->cx = pbih->cx;
  1181.     // set rest to zero
  1182.     memset((PCHAR)pbmi2 +16, 0, sizeof(*pbih2)-16);
  1183.   } /* endif */
  1184.  
  1185.   /* We have the 2.0 bitmap info structure set...............................*/
  1186.   /* move to the stream to the start of the bitmap data......................*/
  1187.   rc = fseek(File, pbfh2->offBits, SEEK_SET);
  1188.   if (!SEEKOK(rc)) goto ExitLoadBMP;
  1189.  
  1190.   /* Read the bitmap data, the read size is derived using the magic formula..*/
  1191.   /* The bitmap scan line is aligned on a doubleword boundary................*/
  1192.   /* The size of the scan line is the number of pels times the bpp...........*/
  1193.   /* After aligning it, we divide by 4 to get the number of bytes, and.......*/
  1194.   /* multiply by the number of scan lines and the number of pel planes.......*/
  1195.   if ( pbmi2->ulCompression ){
  1196.      ulDataSize = pbmi2->cbImage;
  1197.   } else {
  1198.      ulDataSize = (((pbmi2->cBitCount * pbmi2->cx) + 31) / 32) * 4 *
  1199.                    pbmi2->cy * pbmi2->cPlanes;
  1200.   } /* endif */
  1201.   pData = (PBYTE)MyMalloc(ulDataSize);
  1202.   if (!pData) goto ExitLoadBMP;
  1203.   rc = READFILE(pData, 1, ulDataSize, File);
  1204.   if (rc != ulDataSize) goto ExitLoadBMP;
  1205.  
  1206.   /* Now, we create the bitmap...............................................*/
  1207.   sizel.cx = pbmi2->cx;
  1208.   sizel.cy = pbmi2->cy;
  1209.  
  1210.   hBmp= GpiCreateBitmap(hPS, (PBITMAPINFOHEADER2)pbmi2, CBM_INIT, pData, pbmi2);
  1211.  
  1212.   ExitLoadBMP:
  1213.   if (pData) MyFree(pData);
  1214.   if (pbafh2) MyFree(pbafh2);
  1215.   CLOSEFILE(File);
  1216.   WinReleasePS(hPS);
  1217.   return(hBmp);
  1218. }
  1219.  
  1220.  
  1221.  
  1222. //----------------------------------------------------------------------------
  1223. // UCMenuSelectColor : internal function (no entry in the user's doc)
  1224. //----------------------------------------------------------------------------
  1225. // :pfunction res=&IDF_SELCOL. name='UCMenuSelectColor' text='Add a entry in the color palette'.
  1226. // This function add an entry in the color palette
  1227. // :syntax name='UCMenuSelectColor' params='Color, hps' return='colorIndex' .
  1228. // :fparams.
  1229. // :fparam name='Color' type='LONG' io='input' .
  1230. // RGB value of the chosen color
  1231. // :fparam name='hps' type='HPS' io='input' .
  1232. // HPS in which indexed color palette we add an entry
  1233. // :freturns.
  1234. // :fparam name='colorIndex' type='ULONG' io='return'.
  1235. // Index of the added color
  1236. // :efparams.
  1237. // :remarks.
  1238. // :related.
  1239. // :epfunction.
  1240. //----------------------------------------------------------------------------
  1241. ULONG _Optlink       UCMenuSelectColor(LONG Color, HPS hps)
  1242. {
  1243.    LONG  alArray[4];
  1244.  
  1245.    // ------------------------------------------------------------------------------------------
  1246.    // -- Toolkit 2.1 bug "GpiQueryColorData" in pmgpi.h and "GpiQueryColordata" in os2386.lib !!
  1247.    // -- -> prototype added in ucmenus.c
  1248.    // ------------------------------------------------------------------------------------------
  1249.    GpiQueryColordata(hps, 3L, alArray);
  1250.    GpiCreateLogColorTable( hps,
  1251.                            0L,
  1252.                            LCOLF_CONSECRGB,
  1253.                            alArray[QCD_LCT_HIINDEX] + 1,
  1254.                            1L,
  1255.                            &Color );
  1256.  
  1257.    return (alArray[QCD_LCT_HIINDEX]+1);
  1258.  
  1259. }
  1260.  
  1261. //----------------------------------------------------------------------------
  1262. // UCMenuSetBmpBgColor : internal function (no entry in the user's doc)
  1263. //----------------------------------------------------------------------------
  1264. // This function is called when the background color of a bitmap needs to be
  1265. // changed to match the current background face color of the toolbar.  This
  1266. // is done by reading the bitmap color table and changing the entry that
  1267. // corresponds to the bitmap background.  The bitmap is then updated with the
  1268. // new color table.
  1269. //----------------------------------------------------------------------------
  1270. VOID _Optlink UCMenuSetBmpBgColor( PUCMITEM pUCMItem, PUCMDATA UCMData, HPS hps )
  1271. {
  1272.  
  1273.   BITMAPINFOHEADER2 BmpHeader;            // Bitmap header
  1274.   PBYTE        pbBits = NULL;             // Ptr to bitmap pixel values
  1275.   PBITMAPINFO2 BmpInfo = NULL;            // Bitmap header + color table
  1276.   ULONG        BitsLen;                   // Length of bitmap pixel buffer
  1277.   ULONG        BmpInfoLen;                // Length of bitmap header + color table
  1278.   ULONG        ulMaxPaletteIndex;
  1279.  
  1280.   BmpHeader.cbFix = sizeof( BITMAPINFOHEADER2 );
  1281.   GpiQueryBitmapInfoHeader( pUCMItem->hBmp, &BmpHeader );
  1282.  
  1283.   // We can only background color map standard format bitmaps (2,16,256 color). 
  1284.   // With more work we could do 24-bit (true color) bitmaps, but it would be
  1285.   // very slow since we would have to walk the bitmap and change every pixel
  1286.   // that was in the background color.
  1287.  
  1288.   switch (BmpHeader.cBitCount) {
  1289.     case 1:
  1290.     case 4:
  1291.     case 8:
  1292.       break;    // continue and process
  1293.     default:
  1294.       return;   // no can do, just return
  1295.   }
  1296.  
  1297.   // Number of bytes in bitmap is width x bits/pel x planes x height
  1298.   // with rounding up of each line to a 4 byte boundry
  1299.   BitsLen = (((BmpHeader.cBitCount * BmpHeader.cx)+31)/32)*4  // one row on 4-byte boundry
  1300.              * BmpHeader.cPlanes                           // number of planes
  1301.              * BmpHeader.cy;                               // bitmap height
  1302.  
  1303.   // Size of BITMAPINFO2 structure we need is basic structure size plus
  1304.   // room for bitmap color table.  Color table is either the exact
  1305.   // size given in the bitmap header, or large enough to hold
  1306.   // the bigest pel index value (which depends on bits/pel). 
  1307.  
  1308.   if (BmpHeader.cclrUsed == 0)              // All index values are used
  1309.     ulMaxPaletteIndex = 1 << BmpHeader.cBitCount;
  1310.   else
  1311.     ulMaxPaletteIndex = BmpHeader.cclrUsed; // Only this many used
  1312.  
  1313.  
  1314.   BmpInfoLen = sizeof( BITMAPINFO2 ) + (sizeof( RGB2 ) * ulMaxPaletteIndex);
  1315.  
  1316.   if (   ( pbBits = (PBYTE)MyMalloc( BitsLen ) )
  1317.       && ( BmpInfo = (PBITMAPINFO2)MyMalloc( BmpInfoLen ) ) ) {
  1318.      LONG lScanRead;
  1319.      HBITMAP  hbmpOld;
  1320.  
  1321.      // Must have bitmap in memory device context to change it
  1322.      hbmpOld = GpiSetBitmap( UCMData->hpsMem, pUCMItem->hBmp );
  1323.  
  1324.      /* Copy header info to new structure with room for color table */
  1325.      *((BITMAPINFOHEADER2 *)BmpInfo) = BmpHeader;
  1326.      BmpInfo->cbFix = sizeof( BITMAPINFOHEADER2 );
  1327.  
  1328.      /* Read bitmap and fill in the color table */
  1329.      lScanRead = GpiQueryBitmapBits( UCMData->hpsMem, 0, BmpHeader.cy, pbBits, BmpInfo );
  1330.  
  1331.      if ( lScanRead == BmpHeader.cy ) {
  1332.         if (UCMData->Style & UCS_CHNGBMPBG) {  // Use app-supplied background color
  1333.           int i;
  1334.           RGB2 rgbOldBg;
  1335.  
  1336.           rgbOldBg.bRed      = (BYTE)( (UCMData->BgBmp & 0x00FF0000L)>>16 );
  1337.           rgbOldBg.bGreen    = (BYTE)( (UCMData->BgBmp & 0x0000FF00L)>>8 );
  1338.           rgbOldBg.bBlue     = (BYTE)  (UCMData->BgBmp & 0x000000FFL);
  1339.           /* Locate all color table entries for the background bitmap color */
  1340.           /* and change them to the toolbar background color.               */
  1341.           for (i=0;i<ulMaxPaletteIndex ;i++ ) {
  1342.              if (  ( BmpInfo->argbColor[i].bRed   == rgbOldBg.bRed   )
  1343.                  &&( BmpInfo->argbColor[i].bGreen == rgbOldBg.bGreen )
  1344.                  &&( BmpInfo->argbColor[i].bBlue  == rgbOldBg.bBlue  ) ) {
  1345.                 BmpInfo->argbColor[i].bRed      = (BYTE)( (UCMData->ItemBgColor & 0x00FF0000L)>>16 );
  1346.                 BmpInfo->argbColor[i].bGreen    = (BYTE)( (UCMData->ItemBgColor & 0x0000FF00L)>>8 );
  1347.                 BmpInfo->argbColor[i].bBlue     = (BYTE)  (UCMData->ItemBgColor & 0x000000FFL);
  1348.                 BmpInfo->argbColor[i].fcOptions = 0;
  1349.              } // endif
  1350.           } // endfor
  1351.  
  1352.         } // if UCS_CHNGBMPBG style
  1353.  
  1354.         else { // Must be AUTO color mapping style
  1355.           ULONG BgColorIndex;
  1356.  
  1357.           // Get first pixel value which will point to the color entry for the background
  1358.           switch (BmpHeader.cBitCount) {
  1359.             case 1:  // Monochrome (1-bit color index, MSB of 1st byte is 1st pixel)
  1360.               BgColorIndex = *pbBits >> 7;
  1361.               break;
  1362.             case 4:  // 16-color (1/2 byte color index, upper nibble is 1st pixel)
  1363.               BgColorIndex = *pbBits >> 4;
  1364.               break;
  1365.             case 8:  // 256-color (1 byte color index)
  1366.               BgColorIndex = *pbBits;
  1367.               break;
  1368.           }
  1369.           // Modify the color table with toolbar background color
  1370.           BmpInfo->argbColor[BgColorIndex].bRed      = (BYTE)( (UCMData->ItemBgColor & 0x00FF0000L)>>16 );
  1371.           BmpInfo->argbColor[BgColorIndex].bGreen    = (BYTE)( (UCMData->ItemBgColor & 0x0000FF00L)>>8 );
  1372.           BmpInfo->argbColor[BgColorIndex].bBlue     = (BYTE)  (UCMData->ItemBgColor & 0x000000FFL);
  1373.           BmpInfo->argbColor[BgColorIndex].fcOptions = 0;
  1374.         } // AUTO style
  1375.  
  1376.         /* Update the bitmap with new color table */
  1377.         GpiSetBitmapBits( UCMData->hpsMem, 0, lScanRead, pbBits, BmpInfo );
  1378.  
  1379.      } // endif
  1380.  
  1381.      GpiSetBitmap( UCMData->hpsMem, hbmpOld ); // Deselect from memory device
  1382.  
  1383.   } // endif
  1384.  
  1385.   if ( pbBits )       { MyFree( pbBits ); }
  1386.   if ( BmpInfo ) { MyFree( BmpInfo );  }
  1387.  
  1388.   return;
  1389. }
  1390.  
  1391. //----------------------------------------------------------------------------
  1392. // UCMenu3DFrame : internal function (no entry in the user's doc)
  1393. //----------------------------------------------------------------------------
  1394. // :pfunction res=&IDF_3DFRAM. name='UCMenu3DFrame' text='Draw a 3D frame'.
  1395. // This function draws a 3D frame
  1396. // :syntax name='UCMenu3DFrame' params='hps, rcl, hilited' return='-' .
  1397. // :fparams.
  1398. // :fparam name='hps' type='HPS' io='input' .
  1399. // HPS where we draw
  1400. // :fparam name='rcl' type='PRECTL' io='input' .
  1401. // Upper right exclusive rectangle of the frame
  1402. // :fparam name='hilited' type='USHORT' io='input'.
  1403. // Type of the frame&colon.
  1404. // :dl compact.
  1405. // :dt.<>0
  1406. // :dd.Hilited item
  1407. // :dt.0
  1408. // :dd.Non hilited item
  1409. // :edl.
  1410. // :freturns.
  1411. // :fparam name='-' type='VOID' io='-'.
  1412. // Nothing
  1413. // :efparams.
  1414. // :remarks.
  1415. // :related.
  1416. // :epfunction.
  1417. //----------------------------------------------------------------------------
  1418. VOID _Optlink UCMenu3DFrame(HPS hps, PRECTL rcl, USHORT hilited)
  1419. {
  1420. #if 0
  1421.    POINTL pt;
  1422.  
  1423.    pt.x = rcl->xLeft;
  1424.    pt.y = rcl->yBottom ;
  1425.    GpiMove(hps, &pt);
  1426.    pt.x  = rcl->xRight - 1;
  1427.    GpiSetColor(hps, hilited?SYSCLR_BUTTONLIGHT:SYSCLR_BUTTONDARK);
  1428.    GpiLine(hps, &pt);
  1429.    pt.y  = rcl->yTop - 1;
  1430.    GpiLine(hps, &pt);
  1431.    pt.x = rcl->xLeft;
  1432.    GpiSetColor(hps,  hilited?SYSCLR_BUTTONDARK:SYSCLR_BUTTONLIGHT);
  1433.    GpiLine(hps, &pt);
  1434.    pt.y = rcl->yBottom;
  1435.    GpiLine(hps, &pt);
  1436. #endif
  1437.    //Simpler, but undocumented PM way to draw 3D borders...
  1438.    #define DB_RAISED    0x0400
  1439.    #define DB_DEPRESSED 0x0800
  1440.    WinDrawBorder( hps, rcl, 1, 1, 0, 0, ( hilited ? DB_DEPRESSED : DB_RAISED ) );
  1441. }
  1442.  
  1443. //----------------------------------------------------------------------------
  1444. // UCMenuMakeTemplate :
  1445. //----------------------------------------------------------------------------
  1446. // :function res=&IDF_MAKETMP. name='UCMenuMakeTemplate' text='Builds a menu template'.
  1447. // This function builds the menu template associated with a specified ucmenu.
  1448. // :syntax name='UCMenuMakeTemplate' params='hwndUCMenu, pBufLen' return='pBuffer' .
  1449. // :fparams.
  1450. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  1451. // UCMenu window handle.
  1452. // :fparam name='pBufLen' type='PULONG' io='output' .
  1453. // Pointer to the ucmenu template buffer length.
  1454. // :freturns.
  1455. // :fparam name='pBuffer' type='PVOID' io='return'.
  1456. // Pointer to the template (NULL if error), has to be freed by the caller with UCMenuFree.
  1457. // :efparams.
  1458. // :remarks.
  1459. // :related.
  1460. // :efunction.
  1461. //----------------------------------------------------------------------------
  1462. PVOID APIENTRY  UCMenuMakeTemplate(HWND hwndUCMenu, PULONG pBufLen)
  1463. {
  1464.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  1465.    if ( UCMData && UCMData->hwndMenu ) {
  1466.       HWND hwndMenu = UCMData->hwndMenu;
  1467.       ULONG ulLen   = UCMenuTemplateLen( hwndMenu ) + 8;
  1468.       PVOID pBuf    = MyMalloc( ulLen ); // 8 is the size of the signature and version number
  1469.  
  1470.       if ( pBuf ) {
  1471.          *( (PULONG)pBuf ) = UCMTMPLSIG;
  1472.          *( (PULONG)( (PBYTE)pBuf + sizeof( ULONG ) ) ) = UCMTMPLVERSION;
  1473.  
  1474.          UCMenuMakeTemplate2( hwndMenu, (PVOID)( (PBYTE)pBuf + 8 ), 0 );
  1475.       } else {
  1476.          ulLen = 0;
  1477.       } // endif
  1478.  
  1479.       *pBufLen = ulLen;
  1480.       return pBuf;
  1481.    } else {
  1482.       *pBufLen = 0;
  1483.       return NULL;
  1484.    } // endif
  1485. }
  1486.  
  1487. //----------------------------------------------------------------------------
  1488. // UCMenuTemplateLen :
  1489. //----------------------------------------------------------------------------
  1490. // :pfunction res=&IDF_TMPLEN. name='UCMenuTemplateLen' text='Calculates the length of a template'.
  1491. // This function returns the length needed for the template associated to a ucmenu.
  1492. // :syntax name='UCMenuTemplateLen' params='hwndMenu' return='ulLen' .
  1493. // :fparams.
  1494. // :fparam name='hwndMenu' type='HWND' io='input' .
  1495. // Menu window handle.
  1496. // :freturns.
  1497. // :fparam name='BufLen' type='ULONG' io='return'.
  1498. // Length neededfor the template
  1499. // :efparams.
  1500. // :remarks.
  1501. // :related.
  1502. // :epfunction.
  1503. //----------------------------------------------------------------------------
  1504. ULONG  _Optlink UCMenuTemplateLen( HWND hwndMenu )
  1505. {
  1506.   MENUTEMPLATE  Mt;
  1507.   PMENUTEMPLATE pMt = &Mt;
  1508.   PMTI          pMti;
  1509.   MENUITEM      Mi;
  1510.   USHORT        NbOfItems = (SHORT)WinSendMsg(hwndMenu, MM_QUERYITEMCOUNT, NULL, NULL);
  1511.   USHORT        i, itemID;
  1512.   SHORT         sLen = 0;
  1513.  
  1514.   pMti = (PMTI)&(pMt->c);
  1515.  
  1516.   for (i=0 ; i<NbOfItems ; i++ ) {
  1517.     itemID = (USHORT)WinSendMsg(hwndMenu,
  1518.                                 MM_ITEMIDFROMPOSITION,
  1519.                                 MPFROMSHORT(i),
  1520.                                 NULL);
  1521.     WinSendMsg(hwndMenu,
  1522.                MM_QUERYITEM,
  1523.                MPFROM2SHORT(itemID, FALSE),
  1524.                MPFROMP(&Mi));
  1525.  
  1526.  
  1527.     if (Mi.afStyle & MIS_TEXT || Mi.afStyle & MIS_BITMAP) {
  1528.       sLen = (SHORT)WinSendMsg(hwndMenu,
  1529.                                MM_QUERYITEMTEXTLENGTH,
  1530.                                MPFROMSHORT(Mi.id),
  1531.                                NULL);
  1532.       sLen++;
  1533.     } else {
  1534.       if (Mi.afStyle & MIS_OWNERDRAW) {
  1535.         sLen = 5; // we have the 5 delimiters no matter what
  1536.         if (ITEM(&Mi, pszText)) {
  1537.           sLen += strlen(ITEM(&Mi, pszText));
  1538.         } /* endif */
  1539.  
  1540.         if (ITEM(&Mi, pszBmp)) {
  1541.           sLen += strlen(ITEM(&Mi, pszBmp));
  1542.         } /* endif */
  1543.  
  1544.         if (ITEM(&Mi, pszAction)) {
  1545.           sLen += strlen((PSZ)ITEM(&Mi, pszAction));
  1546.         } /* endif */
  1547.  
  1548.         if (ITEM(&Mi, pszParameters)) {
  1549.           sLen += strlen((PSZ)ITEM(&Mi, pszParameters));
  1550.         } /* endif */
  1551.  
  1552.         if (ITEM(&Mi, pszData)) {
  1553.           sLen += strlen((PSZ)ITEM(&Mi, pszData));
  1554.         } /* endif */
  1555.  
  1556.         sLen++;
  1557.       } else {
  1558.         sLen = 0;
  1559.       } /* endif */
  1560.     } /* endif */
  1561.  
  1562.     pMti = (PMTI)((ULONG)pMti->c + sLen);
  1563.     if (Mi.afStyle & MIS_SUBMENU) {
  1564.       pMti = (PMTI)( (ULONG)pMti + UCMenuTemplateLen( Mi.hwndSubMenu ) );
  1565.     } /* endif */
  1566.   } /* endfor */
  1567.  
  1568.   return (ULONG)pMti - (ULONG)pMt;
  1569. }
  1570.  
  1571. //----------------------------------------------------------------------------
  1572. // UCMenuMakeTemplate2 :
  1573. //----------------------------------------------------------------------------
  1574. // :pfunction res=&IDF_MAKETMP2. name='UCMenuMakeTemplate2' text='Builds a menu template'.
  1575. // This function builds the menu template associated with a specified menu.
  1576. // :syntax name='UCMenuMakeTemplate2' params='hwndMenu, pBuffer' return='pEndBuffer' .
  1577. // :fparams.
  1578. // :fparam name='hwndMenu' type='HWND' io='input' .
  1579. // Menu window handle.
  1580. // :fparam name='pBuffer' type='PVOID' io='input' .
  1581. // Pointer to the menu template buffer
  1582. // :fparam name='MenuAttr' type='SHORT' io='input'.
  1583. // MIA_SUBMENU if processing a submenu, else 0.
  1584. // :freturns.
  1585. // :fparam name='pEndBuffer' type='PVOID' io='return'.
  1586. // Pointer to the end of the template, plus one.
  1587. // :efparams.
  1588. // :remarks.
  1589. // pBuffer has to be allocated before, and freed after this call
  1590. // :related.
  1591. // :epfunction.
  1592. //----------------------------------------------------------------------------
  1593. //(MAM) Added MenuAttr parameter to detect recursive submenu processing.
  1594. PVOID _Optlink  UCMenuMakeTemplate2(HWND hwndMenu, PVOID pBuf, USHORT MenuAttr)
  1595. {
  1596.   PMENUTEMPLATE pMt = (PMENUTEMPLATE)pBuf;
  1597.   PMTI          pMti;
  1598.   MENUITEM      Mi;
  1599.   USHORT        NbOfItems = (SHORT)WinSendMsg(hwndMenu, MM_QUERYITEMCOUNT, NULL, NULL);
  1600.   USHORT        i, itemID;
  1601.   SHORT         sLen = 0, pszLen;
  1602.   UCHAR ucDelim = '\t';
  1603.  
  1604.   pMt->Version=0;
  1605.   pMt->CodePage=0x01B5;
  1606.   pMt->Offset=4;
  1607.   pMt->Count=NbOfItems;
  1608.   pMti = (PMTI)&(pMt->c);
  1609.  
  1610.   for (i=0 ; i<NbOfItems ; i++ ) {
  1611.     itemID = (USHORT)WinSendMsg(hwndMenu,
  1612.                                 MM_ITEMIDFROMPOSITION,
  1613.                                 MPFROMSHORT(i),
  1614.                                 NULL);
  1615.     WinSendMsg(hwndMenu,
  1616.                MM_QUERYITEM,
  1617.                MPFROM2SHORT(itemID, FALSE),
  1618.                MPFROMP(&Mi));
  1619.  
  1620.     pMti->afStyle     = Mi.afStyle & (USHORT)~MIS_OWNERDRAW;
  1621.     if (Mi.afStyle & MIS_OWNERDRAW) { // transform MIS_OWNERDRAW into MIS_TEXT !!
  1622.       pMti->afStyle  |= MIS_TEXT;
  1623.     } /* endif */
  1624.  
  1625.     /* Remove most attributes since app will need to reset them when menu is loaded */
  1626.     /* according to (then current) application state.                               */
  1627.     pMti->afAttribute = Mi.afAttribute & (USHORT)~MIA_CHECKED;
  1628.     pMti->afAttribute = Mi.afAttribute & (USHORT)~MIA_DISABLED;
  1629.     pMti->afAttribute = Mi.afAttribute & (USHORT)~MIA_HILITED;
  1630.  
  1631.     pMti->idItem      = Mi.id;
  1632.  
  1633.     if (Mi.afStyle & MIS_TEXT || Mi.afStyle & MIS_BITMAP) {
  1634.       sLen = (SHORT)WinSendMsg(hwndMenu,
  1635.                                MM_QUERYITEMTEXTLENGTH,
  1636.                                MPFROMSHORT(Mi.id),
  1637.                                NULL);
  1638.       WinSendMsg(hwndMenu,
  1639.                  MM_QUERYITEMTEXT,
  1640.                  MPFROM2SHORT(Mi.id, ++sLen),
  1641.                  MPFROMP(pMti->c));
  1642.     } else {
  1643.       if (Mi.afStyle & MIS_OWNERDRAW) {
  1644.         sLen = 0;
  1645.         pMti->c[0]='\0';
  1646.  
  1647. #if 0
  1648.         if (ITEM(&Mi, pszText)) {
  1649.           sLen = strlen(ITEM(&Mi, pszText));
  1650.           memcpy(pMti->c, ITEM(&Mi, pszText), sLen);
  1651.         } /* endif */
  1652. #endif
  1653.  
  1654.         if (ITEM(&Mi, pszText)) {
  1655.           pszLen = strlen(ITEM(&Mi, pszText));
  1656.           pMti->c[sLen]=ucDelim;
  1657.           memcpy(&pMti->c[++sLen], ITEM(&Mi, pszText), pszLen);
  1658.           sLen += pszLen;
  1659.         } else {
  1660.           pMti->c[sLen]=ucDelim;
  1661.           sLen++;
  1662.         } /* endif */
  1663.  
  1664.         if (ITEM(&Mi, pszBmp)) {
  1665.           pszLen = strlen(ITEM(&Mi, pszBmp));
  1666.           pMti->c[sLen]=ucDelim;
  1667.           memcpy(&pMti->c[++sLen], ITEM(&Mi, pszBmp), pszLen);
  1668.           sLen += pszLen;
  1669.         } else {
  1670.           pMti->c[sLen]=ucDelim;
  1671.           sLen++;
  1672.         } /* endif */
  1673.  
  1674.         if (ITEM(&Mi, pszAction)) {
  1675.           pszLen = strlen((PSZ)ITEM(&Mi, pszAction));
  1676.           pMti->c[sLen]=ucDelim;
  1677.           memcpy(&pMti->c[++sLen], ITEM(&Mi, pszAction), pszLen);
  1678.           sLen += pszLen;
  1679.         } else {
  1680.           pMti->c[sLen]=ucDelim;
  1681.           sLen++;
  1682.         } /* endif */
  1683.  
  1684.         if (ITEM(&Mi, pszParameters)) {
  1685.           pszLen = strlen((PSZ)ITEM(&Mi, pszParameters));
  1686.           pMti->c[sLen]=ucDelim;
  1687.           memcpy(&pMti->c[++sLen], ITEM(&Mi, pszParameters), pszLen);
  1688.           sLen += pszLen;
  1689.         } else {
  1690.           pMti->c[sLen]=ucDelim;
  1691.           sLen++;
  1692.         } /* endif */
  1693.  
  1694.         if (ITEM(&Mi, pszData)) {
  1695.           pszLen = strlen((PSZ)ITEM(&Mi, pszData));
  1696.           pMti->c[sLen]=ucDelim;
  1697.           memcpy(&pMti->c[++sLen], ITEM(&Mi, pszData), pszLen);
  1698.           sLen += pszLen;
  1699.         } else {
  1700.           pMti->c[sLen]=ucDelim;
  1701.           sLen++;
  1702.         } /* endif */
  1703.  
  1704.         pMti->c[sLen]='\0';
  1705.         sLen++;
  1706.       } else {
  1707.         pMti->c[0] = '\0';
  1708.         sLen       = 0;
  1709.       } /* endif */
  1710.     } /* endif */
  1711.  
  1712.     pMti = (PMTI)((ULONG)pMti->c + sLen);
  1713.     if (Mi.afStyle & MIS_SUBMENU) {
  1714.       pMti = (PMTI)UCMenuMakeTemplate2(Mi.hwndSubMenu, (PVOID)pMti, MIS_SUBMENU);
  1715.     } /* endif */
  1716.   } /* endfor */
  1717.  
  1718.   pMt->Length = (ULONG)pMti - (ULONG)pMt;
  1719.   return (PVOID)pMti;
  1720. }
  1721. //----------------------------------------------------------------------------
  1722. // UCMenuSaveTemplate :
  1723. //----------------------------------------------------------------------------
  1724. // :function res=&IDF_SAVETMP. name='UCMenuSaveTemplate' text='Saves a menu template'.
  1725. // This function builds and saves a ucmenu template.
  1726. // :syntax name='UCMenuSaveTemplate' params='hwndUCMenu, pszFileName' return='bRc' .
  1727. // :fparams.
  1728. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  1729. // UCMenu window handle.
  1730. // :fparam name='pszFileName' type='PSZ' io='input' .
  1731. // File name (NULL-terminated string)
  1732. // :freturns.
  1733. // :fparam name='bRc' type='BOOL' io='return'.
  1734. // FALSE if an error occured.
  1735. // :efparams.
  1736. // :remarks.
  1737. // :related.
  1738. // UCMenuMakeTemplate
  1739. // :efunction.
  1740. //----------------------------------------------------------------------------
  1741. BOOL APIENTRY  UCMenuSaveTemplate(HWND hwndUCMenu, PSZ pszFileName)
  1742. {
  1743.   PVOID  pBuffer;
  1744.   USHORT size;
  1745.   BOOL   bRc = FALSE;
  1746.   ULONG  ulBufLen;
  1747.  
  1748.  
  1749.   pBuffer = UCMenuMakeTemplate(hwndUCMenu, &ulBufLen);
  1750.   if (pBuffer) {
  1751.     size = (USHORT)ulBufLen;
  1752.     if (size) {
  1753.       ULONG ulAction, ulWritten=0;
  1754.       HFILE hFile = NULLHANDLE;
  1755.  
  1756.       if (DosOpen(pszFileName,
  1757.                   &hFile,
  1758.                   &ulAction,
  1759.                   0,
  1760.                   FILE_NORMAL,
  1761.                   OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
  1762.                   OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE|
  1763.                   OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NO_CACHE ,
  1764.                   0L) == 0 ) {
  1765.         DosWrite(hFile, pBuffer, size, &ulWritten);
  1766.         DosClose(hFile);
  1767.         if (ulWritten == size)
  1768.           bRc = TRUE;
  1769.       } /* endif */
  1770.     } /* endif */
  1771.     MyFree(pBuffer);
  1772.   } /* endif */
  1773.  
  1774.   return (bRc);
  1775. }
  1776.  
  1777.  
  1778. //----------------------------------------------------------------------------
  1779. // UCMenuLoadTemplate :
  1780. //----------------------------------------------------------------------------
  1781. // :function res=&IDF_LOADTMP. name='UCMenuLoadTemplate' text='Loads a menu template'.
  1782. // This function loads a menu template from a file.
  1783. // :syntax name='UCMenuLoadTemplate' params='pszFileName, pBufLen' return='pBuffer' .
  1784. // :fparams.
  1785. // :fparam name='pszFileName' type='PSZ' io='input' .
  1786. // File name (NULL-terminated string)
  1787. // :fparam name='pBufLen' type='PULONG' io='output' .
  1788. // Pointer to the length of the allocated buffer.
  1789. // :freturns.
  1790. // :fparam name='pBuffer' type='PVOID' io='input' .
  1791. // Pointer to a buffer (NULL if error).
  1792. // :hp2.Note&colon.:ehp2. The buffer must be freed by the caller using the UCMenuFree() function:enote.
  1793. // :efparams.
  1794. // :remarks.
  1795. // :related.
  1796. // :efunction.
  1797. //----------------------------------------------------------------------------
  1798. PVOID APIENTRY  UCMenuLoadTemplate(PSZ pszFileName, PULONG pBufLen)
  1799. {
  1800.   PVOID       pBuffer;
  1801.   ULONG       ulAction=0, ulRead;
  1802.   FILESTATUS3 flstInfo;
  1803.   HFILE       hFile= NULLHANDLE;
  1804.   APIRET      Error;
  1805.  
  1806.   Error = DosOpen(pszFileName,
  1807.                   &hFile,
  1808.                   &ulAction,
  1809.                   0,
  1810.                   FILE_NORMAL,
  1811.                   OPEN_ACTION_OPEN_IF_EXISTS,
  1812.                   OPEN_ACCESS_READONLY | OPEN_SHARE_DENYREADWRITE,
  1813.                   0L);
  1814.   if (Error) {
  1815.     pBuffer = NULL;
  1816.   } else {
  1817.     if (DosQueryFileInfo(hFile,
  1818.                          1,
  1819.                          (PBYTE)&flstInfo,
  1820.                          sizeof(flstInfo))) {
  1821.       DosClose(hFile);
  1822.       pBuffer = NULL;
  1823.     } else {
  1824.       pBuffer = MyMalloc(flstInfo.cbFile);
  1825.       if (!pBuffer) {
  1826.         DosClose(hFile);
  1827.         *pBufLen = 0;
  1828.       } else {
  1829.         *pBufLen = flstInfo.cbFile;
  1830.         DosRead(hFile,
  1831.                 pBuffer,
  1832.                 flstInfo.cbFile,
  1833.                 &ulRead);
  1834.         DosClose(hFile);
  1835.       } /* endif */
  1836.     } /* endif */
  1837.   } /* endif */
  1838.  
  1839.   return (pBuffer);
  1840. }
  1841.  
  1842. //----------------------------------------------------------------------------
  1843. // UCMenuSaveTemplateIni :
  1844. //----------------------------------------------------------------------------
  1845. // :function res=&IDF_SAVETMPINI. name='UCMenuSaveTemplateIni' text='Saves a menu template'.
  1846. // This function builds and saves a ucmenu template in an ini file.
  1847. // :syntax name='UCMenuSaveTemplateIni' params='hwndUCMenu, pszFileName, pszKeyName' return='bRc' .
  1848. // :fparams.
  1849. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  1850. // UCMenu window handle.
  1851. // :fparam name='pszFileName' type='PSZ' io='input' .
  1852. // File name (NULL-terminated string)
  1853. // :fparam name='pszKeyName' type='PSZ' io='input' .
  1854. // Template name (NULL-terminated string)
  1855. // :freturns.
  1856. // :fparam name='bRc' type='BOOL' io='return'.
  1857. // FALSE if an error occured.
  1858. // :efparams.
  1859. // :remarks.
  1860. // :related.
  1861. // UCMenuMakeTemplate
  1862. // :efunction.
  1863. //----------------------------------------------------------------------------
  1864. BOOL APIENTRY  UCMenuSaveTemplateIni(HWND hwndUCMenu, PSZ pszFileName,
  1865.                                   PSZ pszKeyName)
  1866. {
  1867.   PVOID  pBuffer;
  1868.   BOOL   bRc = FALSE;
  1869.   ULONG  ulBufLen;
  1870.   HINI   hIni;
  1871.   //HWND   hwndMenu = ((PUCMDATA)WinQueryWindowULong(hwndUCMenu,QWL_UCMDATA))->hwndMenu;
  1872.  
  1873.   pBuffer = UCMenuMakeTemplate(hwndUCMenu, &ulBufLen);
  1874.   if (pBuffer) {
  1875.     if (ulBufLen) {
  1876.       hIni = PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP), pszFileName);
  1877.       if (hIni) {
  1878.          PrfWriteProfileData(hIni, UCAPPNAME, pszKeyName, pBuffer, ulBufLen);
  1879.          PrfCloseProfile(hIni);
  1880.          bRc = TRUE;
  1881.       }
  1882.     } /* endif */
  1883.     MyFree(pBuffer);
  1884.   } /* endif */
  1885.  
  1886.   return (bRc);
  1887. }
  1888.  
  1889. //----------------------------------------------------------------------------
  1890. // UCMenuLoadTemplateIni :
  1891. //----------------------------------------------------------------------------
  1892. // :function res=&IDF_LOADTMPINI. name='UCMenuLoadTemplateIni' text='Loads a menu template'.
  1893. // This function loads a menu template from an ini file.
  1894. // :syntax name='UCMenuLoadTemplateIni' params='pszFileName, pszKeyName, pBufLen' return='pBuffer' .
  1895. // :fparams.
  1896. // :fparam name='pszFileName' type='PSZ' io='input' .
  1897. // Ini File name (NULL-terminated string)
  1898. // :fparam name='pszKeyName' type='PSZ' io='input' .
  1899. // Template name (NULL-terminated string)
  1900. // :fparam name='pBufLen' type='PULONG' io='output' .
  1901. // Pointer to the length of the allocated buffer.
  1902. // :freturns.
  1903. // :fparam name='pBuffer' type='PVOID' io='input' .
  1904. // Pointer to a buffer (NULL if error).
  1905. // :hp2.Note&colon.:ehp2. The buffer must be freed by the caller using the UCMenuFree() function:enote.
  1906. // :efparams.
  1907. // :remarks.
  1908. // :related.
  1909. // :efunction.
  1910. //----------------------------------------------------------------------------
  1911. PVOID APIENTRY  UCMenuLoadTemplateIni(PSZ pszFileName, PSZ pszKeyName,
  1912.                                    PULONG pBufLen)
  1913. {
  1914.   PVOID       pBuffer=(PVOID)NULL;
  1915.   HINI        hIni;
  1916.   ULONG       ulSize;
  1917.  
  1918.   hIni = PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP), pszFileName);
  1919.   if (hIni) {
  1920.      PrfQueryProfileSize(hIni, UCAPPNAME, pszKeyName, &ulSize);
  1921.      if (ulSize) {
  1922.         pBuffer = MyMalloc(ulSize);
  1923.      }
  1924.      if (pBuffer) {
  1925.         PrfQueryProfileData(hIni, UCAPPNAME, pszKeyName, pBuffer, &ulSize);
  1926.      }
  1927.      PrfCloseProfile(hIni);
  1928.   }
  1929.   return(pBuffer);
  1930. }
  1931.  
  1932. //----------------------------------------------------------------------------
  1933. // UCMenuSaveStyle :
  1934. //----------------------------------------------------------------------------
  1935. // :function res=&IDF_SAVESTL. name='UCMenuSaveStyle' text='Saves a menu style'.
  1936. // This function saves the informations relative to the style of a ucmenu.
  1937. // :syntax name='UCMenuSaveStyle' params='hwndMenu, pszFileName' return='bRC' .
  1938. // :fparams.
  1939. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  1940. // UCMenu window handle.
  1941. // :fparam name='pszFileName' type='PSZ' io='input' .
  1942. // File name (NULL-terminated string)
  1943. // :freturns.
  1944. // :fparam name='bRC' type='BOOL' io='return'.
  1945. // FALSE if an error occured.
  1946. // :efparams.
  1947. // :remarks.
  1948. // :related.
  1949. // :efunction.
  1950. //----------------------------------------------------------------------------
  1951. BOOL APIENTRY  UCMenuSaveStyle(HWND hwndUCMenu, PSZ pszFileName)
  1952. {
  1953.   PVOID  pBuffer;
  1954.   USHORT size;
  1955.   BOOL   bRC = FALSE;
  1956.   PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  1957.  
  1958.   pBuffer = MyMalloc(MAX_TMPSIZE);
  1959.   if (pBuffer) {
  1960.     PVOID pBufIndex = pBuffer;
  1961.     size = 0;
  1962.     *((PULONG)pBufIndex)   = UCMData->Style;
  1963.     pBufIndex = ((PULONG)pBufIndex)+1;
  1964.     size += sizeof( ULONG );
  1965.     *((PULONG)pBufIndex) = UCMData->cx;
  1966.     pBufIndex = ((PULONG)pBufIndex)+1;
  1967.     size += sizeof( ULONG );
  1968.     *((PULONG)pBufIndex) = UCMData->cy;
  1969.     pBufIndex = ((PULONG)pBufIndex)+1;
  1970.     size += sizeof( ULONG );
  1971.     *((LONG*)pBufIndex) = UCMData->BgColor;
  1972.     pBufIndex = ((LONG*)pBufIndex)+1;
  1973.     size += sizeof( LONG );
  1974.     *((LONG*)pBufIndex) = UCMData->ItemBgColor;
  1975.     pBufIndex = ((LONG*)pBufIndex)+1;
  1976.     size += sizeof( LONG );
  1977.     if (UCMData->pszFontNameSize) {
  1978.        strcpy( pBufIndex, UCMData->pszFontNameSize );
  1979.        size += 1 + strlen( UCMData->pszFontNameSize );
  1980.     } // endif
  1981.     if (size) {
  1982.       ULONG ulAction, ulWritten=0;
  1983.       HFILE hFile = NULLHANDLE;
  1984.  
  1985.       if (DosOpen(pszFileName,
  1986.                   &hFile,
  1987.                   &ulAction,
  1988.                   0,
  1989.                   FILE_NORMAL,
  1990.                   OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
  1991.                   OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE|
  1992.                   OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NO_CACHE ,
  1993.                   0L) == 0 ) {
  1994.         DosWrite(hFile, pBuffer, size, &ulWritten);
  1995.         DosClose(hFile);
  1996.         if (ulWritten == size)
  1997.           bRC = TRUE;
  1998.       } /* endif */
  1999.     } /* endif */
  2000.     MyFree(pBuffer);
  2001.   } /* endif */
  2002.   return (bRC);
  2003. }
  2004.  
  2005.  
  2006. //----------------------------------------------------------------------------
  2007. // UCMenuLoadStyle :
  2008. //----------------------------------------------------------------------------
  2009. // :function res=&IDF_LOADSTL. name='UCMenuLoadStyle' text='Loads a menu style'.
  2010. // This function loads a menu style from a file into a UCMInfo ucmenu
  2011. // creation structure.
  2012. // :syntax name='UCMenuLoadStyle' params='pszFileName, pUCMInfo' return='bSuccess'.
  2013. // :fparams.
  2014. // :fparam name='pszFileName' type='PSZ' io='input' .
  2015. // File name (NULL-terminated string)
  2016. // :fparam name='pUCMInfo' type='UCMINFO *' io='output' .
  2017. // Pointer to the UCMInfo structure in which to load the style
  2018. // :freturns.
  2019. // :fparam name='bSuccess' type='BOOL' io='return' .
  2020. // FALSE if an error occured.
  2021. // :efparams.
  2022. // :remarks.
  2023. // :related.
  2024. // :efunction.
  2025. //----------------------------------------------------------------------------
  2026. BOOL APIENTRY  UCMenuLoadStyle(PSZ pszFileName, PUCMINFO pUCMInfo)
  2027. {
  2028.   BOOL        bSuccess;
  2029.   PVOID       pBuffer;
  2030.   ULONG       ulAction=0, ulRead;
  2031.   FILESTATUS3 flstInfo;
  2032.   HFILE       hFile= NULLHANDLE;
  2033.   APIRET      Error;
  2034.  
  2035.   Error = DosOpen(pszFileName,
  2036.                   &hFile,
  2037.                   &ulAction,
  2038.                   0,
  2039.                   FILE_NORMAL,
  2040.                   OPEN_ACTION_OPEN_IF_EXISTS,
  2041.                   OPEN_ACCESS_READONLY | OPEN_SHARE_DENYREADWRITE,
  2042.                   0L);
  2043.   if (Error) {
  2044.     bSuccess = FALSE;
  2045.   } else {
  2046.     if (DosQueryFileInfo(hFile,
  2047.                          1,
  2048.                          (PBYTE)&flstInfo,
  2049.                          sizeof(flstInfo))) {
  2050.       DosClose(hFile);
  2051.       bSuccess = FALSE;
  2052.     } else {
  2053.       pBuffer = MyMalloc(flstInfo.cbFile);
  2054.       if (!pBuffer) {
  2055.         DosClose(hFile);
  2056.         bSuccess = FALSE;
  2057.       } else {
  2058.         DosRead(hFile,
  2059.                 pBuffer,
  2060.                 flstInfo.cbFile,
  2061.                 &ulRead);
  2062.         DosClose(hFile);
  2063.         if ( ulRead >= ( 3*sizeof(ULONG) + 2*sizeof(LONG) ) ) {
  2064.            PVOID pBufIndex;
  2065.            pBufIndex = pBuffer;
  2066.            pUCMInfo->Style = *(PULONG)pBufIndex;
  2067.            pBufIndex = ((PULONG)pBufIndex)+1;
  2068.            pUCMInfo->cx = *(PULONG)pBufIndex;
  2069.            pBufIndex = ((PULONG)pBufIndex)+1;
  2070.            pUCMInfo->cy = *(PULONG)pBufIndex;
  2071.            pBufIndex = ((PULONG)pBufIndex)+1;
  2072.            pUCMInfo->BgColor = *(LONG*)pBufIndex;
  2073.            pBufIndex = ((LONG*)pBufIndex)+1;
  2074.            pUCMInfo->ItemBgColor = *(LONG*)pBufIndex;
  2075.            pBufIndex = ((LONG*)pBufIndex)+1;
  2076.            if (((PBYTE)pBufIndex-(PBYTE)pBuffer)>ulRead) {
  2077.               *((PBYTE)pBuffer+ulRead-1) = 0;
  2078.               pUCMInfo->pszFontNameSize = MyStrdup( (PSZ)pBufIndex );
  2079.            } else {
  2080.               pUCMInfo->pszFontNameSize = 0;
  2081.            } // endif
  2082.            bSuccess = TRUE;
  2083.         } else {
  2084.            bSuccess = FALSE;
  2085.         } // endif
  2086.       MyFree( pBuffer );
  2087.       } // endif
  2088.     } // endif
  2089.   } // endif
  2090.  
  2091.   return (bSuccess);
  2092. }
  2093.  
  2094. //----------------------------------------------------------------------------
  2095. // UCMenuSaveStyleIni :
  2096. //----------------------------------------------------------------------------
  2097. // :function res=&IDF_SAVESTLINI. name='UCMenuSaveStyleIni' text='Saves a menu style'.
  2098. // This function saves the informations relative to the style of a ucmenu in an ini file.
  2099. // :syntax name='UCMenuSaveStyleIni' params='hwndMenu, pszFileName, pszKeyName' return='bRC' .
  2100. // :fparams.
  2101. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  2102. // UCMenu window handle.
  2103. // :fparam name='pszFileName' type='PSZ' io='input' .
  2104. // File name (NULL-terminated string)
  2105. // :fparam name='pszKeyName' type='PSZ' io='input' .
  2106. // Style name (NULL-terminated string)
  2107. // :freturns.
  2108. // :fparam name='bRC' type='BOOL' io='return'.
  2109. // FALSE if an error occured.
  2110. // :efparams.
  2111. // :remarks.
  2112. // :related.
  2113. // :efunction.
  2114. //----------------------------------------------------------------------------
  2115. BOOL APIENTRY  UCMenuSaveStyleIni(HWND hwndUCMenu, PSZ pszFileName,
  2116.                                PSZ pszKeyName)
  2117. {
  2118.   PVOID  pBuffer;
  2119.   USHORT size;
  2120.   BOOL   bRC = FALSE;
  2121.   PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  2122.  
  2123.   pBuffer = MyMalloc(MAX_TMPSIZE);
  2124.   if (pBuffer) {
  2125.     PVOID pBufIndex = pBuffer;
  2126.     size = 0;
  2127.     *((PULONG)pBufIndex)   = UCMData->Style;
  2128.     pBufIndex = ((PULONG)pBufIndex)+1;
  2129.     size += sizeof( ULONG );
  2130.     *((PULONG)pBufIndex) = UCMData->cx;
  2131.     pBufIndex = ((PULONG)pBufIndex)+1;
  2132.     size += sizeof( ULONG );
  2133.     *((PULONG)pBufIndex) = UCMData->cy;
  2134.     pBufIndex = ((PULONG)pBufIndex)+1;
  2135.     size += sizeof( ULONG );
  2136.     *((LONG*)pBufIndex) = UCMData->BgColor;
  2137.     pBufIndex = ((LONG*)pBufIndex)+1;
  2138.     size += sizeof( LONG );
  2139.     *((LONG*)pBufIndex) = UCMData->ItemBgColor;
  2140.     pBufIndex = ((LONG*)pBufIndex)+1;
  2141.     size += sizeof( LONG );
  2142.     if (UCMData->pszFontNameSize) {
  2143.        strcpy( pBufIndex, UCMData->pszFontNameSize );
  2144.        size += 1 + strlen( UCMData->pszFontNameSize );
  2145.     } // endif
  2146.  
  2147.     if (size) {
  2148.        HINI    hIni;
  2149.        hIni = PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP), pszFileName);
  2150.        if (hIni) {
  2151.           PrfWriteProfileData(hIni, UCAPPNAME, pszKeyName, pBuffer, size);
  2152.           PrfCloseProfile(hIni);
  2153.        }
  2154.     }
  2155.     MyFree(pBuffer);
  2156.   } /* endif */
  2157.   return (bRC);
  2158. }
  2159.  
  2160.  
  2161. //----------------------------------------------------------------------------
  2162. // UCMenuLoadStyleIni :
  2163. //----------------------------------------------------------------------------
  2164. // :function res=&IDF_LOADSTLINI. name='UCMenuLoadStyleIni' text='Loads a menu style'.
  2165. // This function loads a menu style from an ini file into a UCMInfo ucmenu
  2166. // creation structure.
  2167. // :syntax name='UCMenuLoadStyleIni' params='pszFileName, pszKeyName, pUCMInfo' return='bSuccess'.
  2168. // :fparams.
  2169. // :fparam name='pszFileName' type='PSZ' io='input' .
  2170. // File name (NULL-terminated string)
  2171. // :fparam name='pszKeyName' type='PSZ' io='input' .
  2172. // Style name (NULL-terminated string)
  2173. // :fparam name='pUCMInfo' type='UCMINFO *' io='output' .
  2174. // Pointer to the UCMInfo structure in which to load the style
  2175. // :freturns.
  2176. // :fparam name='bSuccess' type='BOOL' io='return' .
  2177. // FALSE if an error occured.
  2178. // :efparams.
  2179. // :remarks.
  2180. // :related.
  2181. // :efunction.
  2182. //----------------------------------------------------------------------------
  2183. BOOL APIENTRY  UCMenuLoadStyleIni(PSZ pszFileName, PSZ pszKeyName,
  2184.                                  PUCMINFO pUCMInfo)
  2185. {
  2186.   BOOL        bSuccess=FALSE;
  2187.   PVOID       pBuffer;
  2188.   HINI        hIni;
  2189.   ULONG       ulSize;
  2190.  
  2191.   hIni = PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP), pszFileName);
  2192.   if (hIni) {
  2193.      PrfQueryProfileSize(hIni, UCAPPNAME, pszKeyName, &ulSize);
  2194.      if (ulSize) {
  2195.        pBuffer = MyMalloc(ulSize);
  2196.        if (pBuffer) {
  2197.          PrfQueryProfileData(hIni, UCAPPNAME, pszKeyName, pBuffer, &ulSize);
  2198.          if ( ulSize >= ( 3*sizeof(ULONG) + 2*sizeof(LONG) ) ) {
  2199.             PVOID pBufIndex;
  2200.             pBufIndex = pBuffer;
  2201.             pUCMInfo->Style = *(PULONG)pBufIndex;
  2202.             pBufIndex = ((PULONG)pBufIndex)+1;
  2203.             pUCMInfo->cx = *(PULONG)pBufIndex;
  2204.             pBufIndex = ((PULONG)pBufIndex)+1;
  2205.             pUCMInfo->cy = *(PULONG)pBufIndex;
  2206.             pBufIndex = ((PULONG)pBufIndex)+1;
  2207.             pUCMInfo->BgColor = *(LONG*)pBufIndex;
  2208.             pBufIndex = ((LONG*)pBufIndex)+1;
  2209.             pUCMInfo->ItemBgColor = *(LONG*)pBufIndex;
  2210.             pBufIndex = ((LONG*)pBufIndex)+1;
  2211.             if (((PBYTE)pBufIndex-(PBYTE)pBuffer)>ulSize) {
  2212.                *((PBYTE)pBuffer+ulSize-1) = 0;
  2213.                pUCMInfo->pszFontNameSize = MyStrdup( (PSZ)pBufIndex );
  2214.             } else {
  2215.                pUCMInfo->pszFontNameSize = 0;
  2216.             } // endif
  2217.             bSuccess = TRUE;
  2218.          } // endif
  2219.          MyFree( pBuffer );
  2220.        } //endif
  2221.      } //endif
  2222.      PrfCloseProfile(hIni);
  2223.   } //endif
  2224.   return(bSuccess);
  2225.  
  2226. }
  2227.  
  2228. //----------------------------------------------------------------------------
  2229. // UCMenuLoadMenuData
  2230. //----------------------------------------------------------------------------
  2231. // :pfunction res=&IDF_LOADMENU. name='UCMenuLoadMenuData' text='Loads the menu data'.
  2232. // This function loads the data associated with the OWNERDRAW items of a menu.
  2233. // :syntax name='UCMenuLoadMenuData' params='hwndMenu, hModule, UCMData, ulVersion, hwndUCM ' return='-' .
  2234. // :fparams.
  2235. // :fparam name='hwndMenu' type='HWND' io='input' .
  2236. // Menu window handle.
  2237. // :fparam name='UCMData' type='PUCMDATA' io='input'
  2238. // Pointer to the UCMDATA structure
  2239. // :fparam name='ulVersion' type='ULONG' io='input'
  2240. // template version
  2241. // :fparam name='hwndUCM' type='HWND' io='input' .
  2242. // UCMenu window handle.
  2243. // :freturns.
  2244. // :fparam name='-' type='VOID' io='-'.
  2245. // Nothing.
  2246. // :efparams.
  2247. // :remarks.
  2248. // This function parses the whole menu (including submenus). It creates ownerdrawn
  2249. // items from special text items.
  2250. // :p.
  2251. // The text field of such items must have the following format &colon.
  2252. // "&lbrk.Text&rbrk.#BitmapID&lbrk.#Action&rbrk.&lbrk.#Data&rbrk.".
  2253. // :dl compact.
  2254. // :dt.:hp2.Text:ehp2.
  2255. // :dd.The text displayed in the bitmap
  2256. // :dt.:hp2.BitmapID:ehp2.
  2257. // :dd.Bitmap identifier or file name
  2258. // :dt.:hp2.Action:ehp2.
  2259. // :dd.Some text associated with the item , for example the name of a macro.
  2260. // :dt.:hp2.Data:ehp2.
  2261. // :dd.Information about the action associated with the item , for example the name of a macro.
  2262. // :edl.
  2263. // :p.
  2264. // The style of these items is replaced by MIS_OWNERDRAW. The item handle contains
  2265. // a pointer to an :link reftype=hd res=&IDT_ITEMD..UCMITEM data structure:elink.
  2266. // :p.
  2267. // Any MIS_BREAK style not for a submenu item is removed.
  2268. // :hp2.Note&colon.:ehp2. This function is automatically called during the creation of a UCMenu.
  2269. // :enote.
  2270. // :xamples.
  2271. // Definition of the menu in a resource file &colon.
  2272. // :xmp.
  2273. // BITMAP 2000 BITMAP1.BMP
  2274. //  ...
  2275. // MENUITEM    "#Item 1#2000#Macro 1",        IDM_MAC1,     MIS_TEXT
  2276. // MENUITEM    "#Item 2#bitmap2.bmp#Macro 2", IDM_MAC2,     MIS_TEXT
  2277. //  ...
  2278. // :exmp.
  2279. // :related.
  2280. // :epfunction.
  2281. //----------------------------------------------------------------------------
  2282. VOID _Optlink  UCMenuLoadMenuData(HWND hwndMenu, PUCMDATA UCMData, ULONG ulVersion, HWND hwndUCM )
  2283. {
  2284.   MENUITEM mi;
  2285.   SHORT    sIndex, sIndexBis, sOtherIndex, ItemID, NewID, NbOfItems, sItemTextLen;
  2286.   PSZ      ItemText, ItemText2;
  2287.   PSZ      pszBmpHandle=0, pszText=0, pszAction=0, pszParameters=0, pszBmp=0, pszAct = 0;
  2288.   PSZ      pszData=0, pszD = 0, pszPar = 0;
  2289.   LONG     pszLen;
  2290.   UCHAR    ucDelim = '\t';
  2291.  
  2292.   WinSetWindowULong( hwndMenu, QWL_USER, (ULONG) UCMData );
  2293.  
  2294.  
  2295.   /*┌────────────────────────────────┐
  2296.     │ Query the Number of menu items │
  2297.     └────────────────────────────────┘*/
  2298.   NbOfItems = (SHORT)WinSendMsg(hwndMenu,
  2299.                                 MM_QUERYITEMCOUNT,
  2300.                                 (MPARAM)0,
  2301.                                 (MPARAM)0);
  2302.  
  2303.   for (sIndex=0 ; sIndex<NbOfItems ; sIndex++) {
  2304.  
  2305.     /*┌─────────────────────────────────┐
  2306.       │ Query the item ID and structure │
  2307.       └─────────────────────────────────┘*/
  2308.     ItemID = (SHORT)WinSendMsg(hwndMenu,
  2309.                                MM_ITEMIDFROMPOSITION,
  2310.                                MPFROMSHORT(sIndex),
  2311.                                (MPARAM)0);
  2312.  
  2313.     sOtherIndex = sIndex;
  2314.     for ( sIndexBis = sIndex + 1; sIndexBis < NbOfItems; sIndexBis++ ) {
  2315.        NewID = (SHORT)WinSendMsg( hwndMenu,
  2316.                                   MM_ITEMIDFROMPOSITION,
  2317.                                   MPFROMSHORT(sIndexBis),
  2318.                                   (MPARAM)0);
  2319.        if ( NewID == ItemID ) {
  2320.           sOtherIndex = sIndexBis;
  2321.        } /* endif */
  2322.     } /* endfor */
  2323.     if ( sOtherIndex != sIndex ) {
  2324.        // Another item has the same ID, so get an unused one
  2325.        // We assume here that when 2 items have the same ID,
  2326.        // MM_QUERYITEM  amd MM_REMOVEITEM use the one
  2327.        // in the first position
  2328.        memset( &mi, 0, sizeof( MENUITEM ) );
  2329.        WinSendMsg(hwndMenu,
  2330.                   MM_QUERYITEM,
  2331.                   MPFROM2SHORT(ItemID,FALSE),
  2332.                   MPFROMP(&mi));
  2333.        NewID = UCMenuGetNewID( hwndMenu, MIT_NONE, UCMData );
  2334.        ItemText2 = 0;
  2335.        sItemTextLen = (SHORT) WinSendMsg( hwndMenu,
  2336.                                           MM_QUERYITEMTEXTLENGTH,
  2337.                                           MPFROMSHORT(ItemID ),
  2338.                                           (MPARAM)0 );
  2339.        if ( sItemTextLen ){
  2340.           ItemText2 = MyMalloc( ++sItemTextLen );
  2341.           if ( ItemText2 ) {
  2342.              WinSendMsg( hwndMenu,
  2343.                          MM_QUERYITEMTEXT,
  2344.                          MPFROM2SHORT( ItemID, sItemTextLen ),
  2345.                          MPFROMP( ItemText2 ) );
  2346.           } /* endif */
  2347.        } /* endif */
  2348.        if ( ItemText2 ) {
  2349.           ItemText = ItemText2;
  2350.        } else {
  2351.           ItemText = "";
  2352.        } /* endif */
  2353.        WinSendMsg(hwndMenu,
  2354.                   MM_REMOVEITEM,
  2355.                   MPFROM2SHORT(ItemID,FALSE),
  2356.                   (MPARAM)0 );
  2357.        mi.id = NewID;
  2358.        if ( mi.hItem ){
  2359.           ITEM( &mi, usId ) = NewID;
  2360.        } /* endif */
  2361.        ItemID = NewID;
  2362.        WinSendMsg( hwndMenu,
  2363.                    MM_INSERTITEM,
  2364.                    MPFROMP( &mi ),
  2365.                    MPFROMP( ItemText ) );
  2366.        if ( ItemText2 ){
  2367.           MyFree( ItemText2 );
  2368.        } /* endif */
  2369.     } /* endif */
  2370.  
  2371.     memset( &mi, 0, sizeof( MENUITEM ) );
  2372.     WinSendMsg(hwndMenu,
  2373.                MM_QUERYITEM,
  2374.                MPFROM2SHORT(ItemID,FALSE),
  2375.                MPFROMP(&mi));
  2376.  
  2377.     /*┌─────────────────────────────────────────────────────────┐
  2378.       │ If it's a Submenu, do a recursive call with hwndSubMenu │
  2379.       └─────────────────────────────────────────────────────────┘*/
  2380.     if (mi.hwndSubMenu){
  2381.        PFNWP pFnwp;
  2382.        UCMenuLoadMenuData(mi.hwndSubMenu, UCMData, ulVersion, hwndUCM );
  2383.        if ( ( pFnwp =(PFNWP)WinQueryWindowPtr( mi.hwndSubMenu, QWP_PFNWP ) ) != SubmenuWndProc ){
  2384.           UCMData->OldSubMenuProc = pFnwp;
  2385.           UCMData->OldSubMenuProc = (PFNWP)WinSubclassWindow( mi.hwndSubMenu, SubmenuWndProc );
  2386.        } // endif
  2387.     }
  2388.  
  2389.     // (MAM) same for SPACER and non-SPACER, so moved here to save code.
  2390.     // If both MIS_SPACER and MIS_TEXT specified, SPACER is used.
  2391.  
  2392.     mi.afStyle |= (USHORT)  MIS_OWNERDRAW ;
  2393.     mi.afStyle &= (USHORT) ~MIS_TEXT;
  2394.     mi.afStyle &= (USHORT) ~MIS_BREAK;  //(MAM) Don't allow BREAK on any item
  2395.  
  2396.     if (mi.afStyle & MIS_SPACER) {
  2397.     /*┌─────────────────────────────────────────────────────────┐
  2398.       │ It's a SPACER item                                      │
  2399.       └─────────────────────────────────────────────────────────┘*/
  2400.  
  2401.        mi.hItem = (LONG)MyMalloc(sizeof(UCMITEM));
  2402.  
  2403.        if (mi.hItem) {
  2404.           memset( (VOID *) mi.hItem, '\0', sizeof(UCMITEM) );
  2405.        } // endif mi.hItem != 0
  2406.  
  2407.  
  2408.       WinSendMsg(hwndMenu,
  2409.                  MM_SETITEM,
  2410.                  MPFROM2SHORT(0,FALSE),
  2411.                  MPFROMP(&mi));
  2412.  
  2413.     } else {
  2414.  
  2415.     /*┌─────────────────────────────────────────────────────────┐
  2416.       │ Assume it is a MIS_TEXT item                            │
  2417.       └─────────────────────────────────────────────────────────┘*/
  2418.       ItemText2 = 0;
  2419.       sItemTextLen = (SHORT) WinSendMsg( hwndMenu,
  2420.                                          MM_QUERYITEMTEXTLENGTH,
  2421.                                          MPFROMSHORT(ItemID ),
  2422.                                          (MPARAM)0 );
  2423.       if ( sItemTextLen ){
  2424.          ItemText2 = MyMalloc( ++sItemTextLen );
  2425.          if ( ItemText2 ) {
  2426.             WinSendMsg( hwndMenu,
  2427.                         MM_QUERYITEMTEXT,
  2428.                         MPFROM2SHORT( ItemID, sItemTextLen ),
  2429.                         MPFROMP( ItemText2 ) );
  2430.          } /* endif */
  2431.       } /* endif */
  2432.       if ( ItemText2 ){
  2433.          ItemText = ItemText2;
  2434.       } else {
  2435.          ItemText = "";
  2436.       } /* endif */
  2437.  
  2438.       /*┌────────────────────────────────────────────────────────────────────┐
  2439.         │ The format is the following : "#Text#Bitmap#Action#Parameters#Data"│
  2440.         │ Text is optional, Bitmap is either a number (bitmap ID) or a       │
  2441.         │ string (file name), Action, Parameters and Data are string         │
  2442.         │ The delimiter (here # is given by the first character of the string│
  2443.         └────────────────────────────────────────────────────────────────────┘*/
  2444.  
  2445.       if ( ulVersion == UCMTMPLVERSION ){
  2446.          ucDelim = ItemText[0];
  2447.          pszBmpHandle = strchr(&ItemText[1], ucDelim);
  2448.       } else {
  2449.          ucDelim = '#';
  2450.          pszBmpHandle = strchr(&ItemText[0], ucDelim);
  2451.       } // endif
  2452.  
  2453.  
  2454.       if (pszBmpHandle) {
  2455.  
  2456.         pszAction = strchr(&pszBmpHandle[1], ucDelim);
  2457.  
  2458.         if(pszAction) {
  2459.           if ( ulVersion == UCMTMPLVERSION ){
  2460.               pszParameters   = (PSZ) strchr((PSZ)(pszAction+1), ucDelim);
  2461.               if ( pszParameters ){
  2462.                  pszData   = (PSZ) strchr((PSZ)(pszParameters+1), ucDelim);
  2463.               } // endif
  2464.            } else {
  2465.               pszParameters = NULL;
  2466.               pszData   = (PSZ) strchr((PSZ)(pszAction+1), ucDelim);
  2467.            } // endif
  2468.         }
  2469.  
  2470.         /*┌───────────────────────┐
  2471.           │ Get the text (if any) │
  2472.           └───────────────────────┘*/
  2473.         if ( ulVersion == UCMTMPLVERSION ){
  2474.            pszLen = (LONG)pszBmpHandle - (LONG)(&ItemText[1]);
  2475.         } else {
  2476.            pszLen = (LONG)pszBmpHandle - (LONG)(&ItemText[0]);
  2477.         } // endif
  2478.         if (pszLen>0) {
  2479.           PSZ StrPtr;
  2480.           pszText = (PSZ)MyMalloc(pszLen + 1);
  2481.           if ( ulVersion == UCMTMPLVERSION ){
  2482.              strncpy(pszText, &ItemText[1], pszLen);
  2483.           } else {
  2484.              strncpy(pszText, &ItemText[0], pszLen);
  2485.           } // endif
  2486.           pszText[pszLen] = '\0';
  2487.           if(StrPtr = strstr(pszText, "~")) {
  2488.              ULONG Index = UCMData->AccelTable->cAccel;
  2489.              //??? should following be using "Index" instead of "sIndex" which is otherwise unused?
  2490.              ULONG cmd = (ULONG) WinSendMsg(hwndMenu, MM_ITEMIDFROMPOSITION, (MPARAM)sIndex, 0L);
  2491.              AddAccelItem(UCMData, StrPtr[1], cmd);
  2492.           }
  2493.         } else {
  2494.           pszText = 0;
  2495.         } /* endif */
  2496.         /*┌──────────────────────────────────────────┐
  2497.           │ Replace '#' with '\0' and get the data   │
  2498.           └──────────────────────────────────────────┘*/
  2499.         if (pszData) {
  2500.           pszData[0] = '\0';
  2501.           pszData++;
  2502.           pszD = (PSZ)MyMalloc(strlen(pszData)+1);
  2503.           strcpy(pszD, pszData);
  2504.         } else {
  2505.           pszD = NULL;
  2506.         } /* endif */
  2507.  
  2508.         /*┌──────────────────────────────────────────┐
  2509.           │ Replace '#' with '\0' and get the params │
  2510.           └──────────────────────────────────────────┘*/
  2511.         if (pszParameters) {
  2512.           pszParameters[0] = '\0';
  2513.           pszParameters++;
  2514.           pszPar = (PSZ)MyMalloc(strlen(pszParameters)+1);
  2515.           strcpy(pszPar, pszParameters);
  2516.         } else {
  2517.           pszPar = NULL;
  2518.         } /* endif */
  2519.  
  2520.         /*┌──────────────────────────────────────────┐
  2521.           │ Replace '#' with '\0' and get the action │
  2522.           └──────────────────────────────────────────┘*/
  2523.         if (pszAction) {
  2524.           pszAction[0] = '\0';
  2525.           pszAction++;
  2526.           if ( ulVersion != UCMTMPLVERSION ){
  2527.              pszParameters = strchr( pszAction, ' ' );
  2528.              if ( pszParameters ) {
  2529.                 *pszParameters = '\0';
  2530.                 pszParameters++;
  2531.                 pszPar = (PSZ)MyMalloc(strlen(pszParameters)+1);
  2532.                 strcpy(pszPar, pszParameters);
  2533.              } // endif
  2534.           } // endif
  2535.           pszAct = (PSZ)MyMalloc(strlen(pszAction)+1);
  2536.           strcpy(pszAct, pszAction);
  2537.         } else {
  2538.           pszAct = NULL;
  2539.         } /* endif */
  2540.  
  2541.         /*┌───────────────────────────────────────┐
  2542.           │ Get the Bitmap text (ID or File name) │
  2543.           └───────────────────────────────────────┘*/
  2544.         if (strlen(&pszBmpHandle[1])>0) {
  2545.            pszBmp = MyMalloc(strlen(&pszBmpHandle[1])+1);
  2546.            strcpy(pszBmp, &pszBmpHandle[1]);
  2547.         } else {
  2548.            pszBmp = 0;
  2549.         } // endif pszBmpHandle<>""
  2550.       } else {
  2551.          pszBmp = 0;
  2552.          pszAct =0;
  2553.          pszPar = 0;
  2554.          pszD = 0;
  2555.          pszText = MyMalloc( strlen(ItemText) + 1);
  2556.          strcpy( pszText, ItemText );
  2557.       } // endif pszBmpHandle
  2558.  
  2559.       /*┌──────────────────────────────────────────┐
  2560.         │Create and fill the item handle structure │
  2561.         └──────────────────────────────────────────┘*/
  2562.       mi.hItem = (LONG)MyMalloc(sizeof(UCMITEM));
  2563.  
  2564.       if (mi.hItem) {
  2565.         memset((PVOID)mi.hItem, 0x00, sizeof(UCMITEM));
  2566.       //ITEM(&mi, hBmp)    = 0;
  2567.         ITEM(&mi, pszBmp)  = pszBmp;
  2568.         ITEM(&mi, pszText) = pszText;
  2569.         ITEM(&mi, pszAction) = pszAct;
  2570.         ITEM(&mi, pszParameters) = pszPar;
  2571.         ITEM(&mi, pszData) = pszD;
  2572.         } // endif mi.hItem != 0
  2573.  
  2574.       // -- The menu is not subclassed yet so it won't load the bitmap
  2575.       UCMenuLoadItemBmp(&mi, UCMData );
  2576.  
  2577.       WinSendMsg(hwndMenu,
  2578.                  MM_SETITEM,
  2579.                  MPFROM2SHORT(0,FALSE),
  2580.                  MPFROMP(&mi));
  2581.        if ( ItemText2 ){
  2582.           MyFree( ItemText2 );
  2583.        } // endif
  2584.     } // endif MIS_TEXT
  2585.  
  2586.   } /* endfor */
  2587.  
  2588. }
  2589.  
  2590. //----------------------------------------------------------------------------
  2591. // UCMenuNotifAll
  2592. //----------------------------------------------------------------------------
  2593. // :pfunction res=&IDF_NOTIFALL. name='UCMenuNotifAll' text='Sends notifications about each item'.
  2594. // This function sends UCN_ADDEDITEM or UCN_DELETEDITEM about all the items in the menu
  2595. // :syntax name='UCMenuNotifAll' params='hwndUCMenu, hwndMenu, usNotif ' return='-' .
  2596. // :fparams.
  2597. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  2598. // UCMenu window handle.
  2599. // :fparam name='hwndMenu' type='HWND' io='input' .
  2600. // Menu window handle.
  2601. // :fparam name='usNotification' type='USHORT' io='input'
  2602. // Notification code, UCN_ADDEDITEM or UCN_DELETEDITEM
  2603. // :freturns.
  2604. // :fparam name='-' type='VOID' io='-'.
  2605. // Nothing.
  2606. // :efparams.
  2607. // :remarks.
  2608. // :related.
  2609. // :epfunction.
  2610. //----------------------------------------------------------------------------
  2611.  
  2612. VOID  _Optlink UCMenuNotifAll(PUCMDATA UCMData, HWND hwndMenu, USHORT usNotif)
  2613. {
  2614.   MENUITEM mi;
  2615.   SHORT    sIndex, ItemID, NbOfItems;
  2616.  
  2617.  
  2618.   NbOfItems = (SHORT)WinSendMsg(hwndMenu,
  2619.                                 MM_QUERYITEMCOUNT,
  2620.                                 (MPARAM)0,
  2621.                                 (MPARAM)0);
  2622.  
  2623.   for (sIndex=0 ; sIndex<NbOfItems ; sIndex++) {
  2624.  
  2625.     ItemID = (SHORT)WinSendMsg(hwndMenu,
  2626.                                MM_ITEMIDFROMPOSITION,
  2627.                                MPFROMSHORT(sIndex),
  2628.                                (MPARAM)0);
  2629.  
  2630.  
  2631.     memset( &mi, 0, sizeof( MENUITEM ) );
  2632.     WinSendMsg(hwndMenu,
  2633.                MM_QUERYITEM,
  2634.                MPFROM2SHORT(ItemID,FALSE),
  2635.                MPFROMP(&mi));
  2636.  
  2637.     if (mi.hwndSubMenu){
  2638.        UCMenuNotifAll(UCMData, mi.hwndSubMenu, usNotif );
  2639.     } // endif
  2640.  
  2641.     WinSendMsg( UCMData->hwndOwner,
  2642.                 WM_CONTROL,
  2643.                 MPFROM2SHORT( UCMData->UCMenuID, usNotif ),
  2644.                 MPFROMSHORT( ItemID ) );
  2645.  
  2646.   } /* endfor */
  2647.  
  2648. }
  2649.  
  2650. //----------------------------------------------------------------------------
  2651. // UCMenuCalcItemSize : internal function (no entry in the user's doc)
  2652. //----------------------------------------------------------------------------
  2653. // :pfunction res=&IDF_CLCITSZ. name='UCMenuCalcItemSize' text='Calculates the scaled size of an item'.
  2654. // This function calculates the size of an item, according to the others so that they are even.
  2655. // :syntax name='UCMenuCalcItemSize' params='poi, style, hwndUCMenu, pCx, pCy' return='-' .
  2656. // :fparams.
  2657. // :fparam name='poi' type='POWNERITEM' io='input' .
  2658. // Pointer to the OWNERITEM structure of the item
  2659. // :fparam name='style' type='USHORT' io='input' .
  2660. // Style of the ucmenu
  2661. // :fparam name='hwndUCMenu' type='HWND' io='input'.
  2662. // Handle of the ucmenu
  2663. // :fparam name='pCx' type='PULONG' input='output' .
  2664. // Width of the item
  2665. // :fparam name='pCy' type='PULONG' input='output' .
  2666. // Height of the item
  2667. // :freturns.
  2668. // :fparam name='-' type='VOID' io='-' .
  2669. // Nothing
  2670. // :efparams.
  2671. // :remarks.
  2672. // :related.
  2673. // :epfunction.
  2674. //----------------------------------------------------------------------------
  2675.  
  2676. VOID _Optlink  UCMenuCalcItemSize( POWNERITEM poi, USHORT Style, HWND hwndUCMenu, ULONG * pCx, ULONG * pCy)
  2677. {
  2678.    PUCMITEM pUCMI = (PUCMITEM) poi->hItem;
  2679.    ULONG MenuStyle = WinQueryWindowULong(hwndUCMenu, QWL_STYLE);
  2680.    PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  2681.  
  2682.    UCMenuCalcUnscaledItemSize( pUCMI, Style, hwndUCMenu, pCx, pCy);
  2683.  
  2684.    if ( poi->fsState & MIS_SPACER ) {
  2685.       *pCx = 8;
  2686.       *pCy = 8;
  2687.    } // endif
  2688.  
  2689.    if (WinQueryWindow(poi->hwnd, QW_OWNER)==hwndUCMenu) {
  2690.       // First level ucmenu item
  2691.       // Submenu ucmenu items are not scaled, since it makes no sense
  2692.       // to scale them according to the items of their parent
  2693.       if  (MenuStyle & CMS_VERT) {
  2694.          *pCx = UCMData->MaxVerticalWidth;
  2695.       } // endif CMS_VERTICAL
  2696.  
  2697.       if  (MenuStyle & CMS_HORZ) {
  2698.          *pCy = UCMData->MaxHorizontalHeight;
  2699.       } // endif CMS_HORIZONTAL
  2700.  
  2701.       if  (MenuStyle & CMS_MATRIX) {
  2702.          *pCx = UCMData->MaxVerticalWidth;
  2703.          *pCy = UCMData->MaxHorizontalHeight;
  2704.       } // endif CMS_MATRIX
  2705.    } // endif
  2706.  
  2707. }
  2708.  
  2709. //----------------------------------------------------------------------------
  2710. // UCMenuCalcUnscaledItemSize : internal function (no entry in the user's doc)
  2711. //----------------------------------------------------------------------------
  2712. // :pfunction res=&IDF_CLCUNSCITSZ. name='UCMenuCalcUnscaledItemSize' text='Calculates the unscaled size of an item'.
  2713. // This function calculates the size of an item
  2714. // :syntax name='UCMenuCalcUnscaledItemSize' params='pUCMI, Style, hwndUCMenu, pCx, pCy' return='-' .
  2715. // :fparams.
  2716. // :fparam name='pUCMI' type='PUCMITEM' io='input' .
  2717. // Pointer to the UCMITEM structure of the ucmenu item
  2718. // :fparam name='Style' type='USHORT' io='input' .
  2719. // Style of the ucmenu
  2720. // :fparam name='hwndUCMenu' type='HWND' io='input'.
  2721. // Handle of the ucmenu
  2722. // :fparam name='pCx' type='PULONG' input='output' .
  2723. // Width of the item
  2724. // :fparam name='pCy' type='PULONG' input='output' .
  2725. // Height of the item
  2726. // :freturns.
  2727. // :fparam name='-' type='VOID' io='-' .
  2728. // Nothing
  2729. // :efparams.
  2730. // :remarks.
  2731. // :related.
  2732. // :epfunction.
  2733. //----------------------------------------------------------------------------
  2734.  
  2735. VOID _Optlink  UCMenuCalcUnscaledItemSize( PUCMITEM pUCMI, USHORT Style, HWND hwndUCMenu,
  2736.                                            ULONG * pCx, ULONG * pCy)
  2737. {
  2738.    PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  2739.  
  2740.    if ( Style & UCS_FORCESIZE ) {
  2741.       *pCx = UCMData->cx;
  2742.       *pCy = UCMData->cy;
  2743.    }
  2744.    else if ( pUCMI ){
  2745.       BITMAPINFOHEADER2 BmpInfo;
  2746.     //ULONG MenuStyle = WinQueryWindowULong(hwndUCMenu, QWL_STYLE);
  2747.  
  2748.       // By default, size the item to its bitmap
  2749.       BmpInfo.cbFix = sizeof(BITMAPINFOHEADER2);
  2750.       if (!GpiQueryBitmapInfoHeader( pUCMI->hBmp, &BmpInfo)){
  2751.          BmpInfo.cx = 0;
  2752.          BmpInfo.cy = 0;
  2753.       }
  2754.       //(MAM) Add one (all sides) for thicker checkable items.
  2755.       *pCx = SUM_ITEM_FRAME_THICK_HORZ + BmpInfo.cx +2;
  2756.       *pCy = SUM_ITEM_FRAME_THICK_VERT + BmpInfo.cy +2;
  2757.    }
  2758.  
  2759.    /* If text is wider, size to text (even in FORCESIZE mode) */
  2760.  
  2761.    if (pUCMI) {
  2762.       if ( pUCMI->pszText && !(Style & UCS_NOTEXT)) {
  2763.          ULONG TextWidth, TextHeight;
  2764.  
  2765.          UCMenuCalcTextSize(pUCMI, hwndUCMenu, &TextWidth, &TextHeight );
  2766.          TextWidth += SUM_ITEM_FRAME_THICK_HORZ;
  2767.          // set width to TextWidth if text larger than bmp
  2768.          if ( TextWidth > *pCx ) {
  2769.             *pCx = TextWidth;
  2770.          }
  2771.          // add the height of the text
  2772.          *pCy += TextHeight;
  2773.  
  2774.       } // endif pszText!=0  && !UCS_NOTEXT
  2775.    } //
  2776. }
  2777.  
  2778. //----------------------------------------------------------------------------
  2779. // UCMenuCalcBmpPos : internal function (no entry in the user's doc)
  2780. //----------------------------------------------------------------------------
  2781. // :pfunction res=&IDF_CLCBMPPOS. name='UCMenuCalcBmpPos' text='Calculates the position of the bitmap in the item'.
  2782. // This function calculates the position of the bitmap inside a ucmenu item
  2783. // :syntax name='UCMenuCalcBmpPos' params='poi, Style, pDestRect' return='-' .
  2784. // :fparams.
  2785. // :fparam name='poi' type='POWNERITEM' io='input' .
  2786. // Pointer to the OWNERITEM structure of the ucmenu item
  2787. // :fparam name='Style' type='USHORT' io='input' .
  2788. // Style of the ucmenu
  2789. // :fparam name='aptlPoints' type='POINTL[4]' io='output'.
  2790. // Destination and source rectangles of the bitmap (upper right exclusive )
  2791. // :freturns.
  2792. // :fparam name='-' type='VOID' io='-' .
  2793. // Nothing
  2794. // :efparams.
  2795. // :remarks.
  2796. // :related.
  2797. // :epfunction.
  2798. //----------------------------------------------------------------------------
  2799. VOID _Optlink  UCMenuCalcBmpPos( POWNERITEM poi, HWND hwndUCMenu, USHORT Style, POINTL aptlPoints[4], PUCMDATA UCMData)
  2800. {
  2801.    LONG    ItemCxForBmp ;
  2802.    LONG    ItemCyForBmp ;
  2803.    ULONG   TextWidth    = 0;
  2804.    ULONG   TextHeight   = 0;
  2805.    PUCMITEM pUCMI = (PUCMITEM) poi->hItem;
  2806.  
  2807.    BITMAPINFOHEADER2 BmpInfo;
  2808.    POINTL  ImageSize;
  2809.  
  2810.    if ( !pUCMI ){
  2811.       return;
  2812.    } // endif
  2813.  
  2814.    /* Get natural bitmap size */
  2815.  
  2816.    BmpInfo.cbFix = sizeof(BITMAPINFOHEADER2);
  2817.    if (!GpiQueryBitmapInfoHeader( ITEM( poi, hBmp ), &BmpInfo)){
  2818.       BmpInfo.cx = 0;
  2819.       BmpInfo.cy = 0;
  2820.    }
  2821.  
  2822.    /* Determine image size to be viewed */
  2823.  
  2824.    if (Style & UCS_FORCESIZE) {  // Size of bitmap image is fixed
  2825.      ImageSize.x = UCMData->cx;
  2826.      ImageSize.y = UCMData->cy;
  2827.    }
  2828.    else {                        // Use natural bitmap size
  2829.      ImageSize.x = BmpInfo.cx;
  2830.      ImageSize.y = BmpInfo.cy;
  2831.    }
  2832.  
  2833.    /* Query the size of the text */
  2834.  
  2835.    if ( ITEM( poi, pszText ) && !(Style&UCS_NOTEXT)) {
  2836.       UCMenuCalcTextSize( pUCMI, hwndUCMenu, &TextWidth, &TextHeight );
  2837.    }
  2838.  
  2839.    ItemCxForBmp =  poi->rclItem.xRight - poi->rclItem.xLeft;
  2840.    ItemCxForBmp -= SUM_ITEM_FRAME_THICK_HORZ;
  2841.    ItemCyForBmp =  poi->rclItem.yTop - poi->rclItem.yBottom;
  2842.    ItemCyForBmp -= SUM_ITEM_FRAME_THICK_VERT;
  2843.  
  2844.    // We won't have the full item to draw the bmp
  2845.    ItemCyForBmp -= TextHeight;
  2846.  
  2847.    if ( ItemCxForBmp < 0 ) { ItemCxForBmp = 0; }
  2848.    if ( ItemCyForBmp < 0 ) { ItemCyForBmp = 0; }
  2849.  
  2850.    aptlPoints[0].x  = poi->rclItem.xLeft;
  2851.    aptlPoints[0].x  += ITEM_FRAME_THICK_LEFT; // do not draw over the frame
  2852.  
  2853.    /* If image is smaller than available space then center it */
  2854.    /* by setting target rectangle points in [0],[1].          */
  2855.  
  2856.    if ( ImageSize.x <= ItemCxForBmp ) {
  2857.       aptlPoints[0].x += (ItemCxForBmp - ImageSize.x)/2;
  2858.       aptlPoints[1].x = aptlPoints[0].x  + ImageSize.x - 1;
  2859.    } else {
  2860.       aptlPoints[1].x  = poi->rclItem.xRight - ITEM_FRAME_THICK_RIGHT - 1;
  2861.    } // endif
  2862.  
  2863.    aptlPoints[0].y = poi->rclItem.yBottom;
  2864.    aptlPoints[0].y += ITEM_FRAME_THICK_BOTTOM ;
  2865.    aptlPoints[0].y+=TextHeight;
  2866.  
  2867.    if ( ImageSize.y <= ItemCyForBmp ) {
  2868.       aptlPoints[0].y += (ItemCyForBmp - ImageSize.y)/2;
  2869.       aptlPoints[1].y = aptlPoints[0].y + ImageSize.y - 1;
  2870.    } else {
  2871.       aptlPoints[1].y = poi->rclItem.yTop - ITEM_FRAME_THICK_TOP - 1;
  2872.    } // endif
  2873.  
  2874.    /* Source rectangle is just the original bitmap */
  2875.  
  2876.    aptlPoints[2].x = 0;
  2877.    aptlPoints[2].y = 0;
  2878.    aptlPoints[3].x = BmpInfo.cx;
  2879.    aptlPoints[3].y = BmpInfo.cy;
  2880.  
  2881. }
  2882.  
  2883.  
  2884. //----------------------------------------------------------------------------
  2885. // UCMenuCalcTextSize : internal function (no entry in the user's doc)
  2886. //----------------------------------------------------------------------------
  2887. // :pfunction res=&IDF_CLCTXTSZ. name='UCMenuCalcTextSize' text='Calculates the size of the item text'.
  2888. // This function calculates the text size of a ucmenu item, according to its font
  2889. // :syntax name='UCMenuCalcTextSize' params='pUCMI, hwndUCMenu, pWidth, pHeight' return='-' .
  2890. // :fparams.
  2891. // :fparam name='pUCMI' type='PUCMITEM' io='input' .
  2892. // Pointer to the UCMITEM structure of the ucmenu item
  2893. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  2894. // Handle of the ucmenu
  2895. // :fparam name='pWidth' type='PULONG' io='output'.
  2896. // Width of the text
  2897. // :fparam name='pHeight' type='PULONG' io='output'.
  2898. // Height of the text
  2899. // :freturns.
  2900. // :fparam name='-' type='VOID' io='-' .
  2901. // Nothing
  2902. // :efparams.
  2903. // :remarks.
  2904. // :related.
  2905. // :epfunction.
  2906. //----------------------------------------------------------------------------
  2907. VOID _Optlink  UCMenuCalcTextSize(PUCMITEM pUCMI, HWND hwndUCMenu, ULONG * pWidth, ULONG * pHeight)
  2908. {
  2909.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong(hwndUCMenu, QWL_UCMDATA);
  2910.  
  2911.    if ( !pUCMI ){
  2912.       return;
  2913.    } // endif
  2914.  
  2915.    if (pUCMI->pszText) {
  2916.    // POINTL aptl[TXTBOX_COUNT];
  2917.       RECTL  Rect;
  2918.       HPS hps = WinGetPS(UCMData->hwndMenu);
  2919.  
  2920.       //(MAM) Use WinDrawText() to calculate required text size, since this
  2921.       // is the API used in the actual drawing.  QueryTextBox() does not always
  2922.       // return correct box size when italic fonts are used.
  2923.       memset(&Rect, 0x00, sizeof(RECTL));
  2924.       Rect.yTop = MAX_INT;
  2925.       Rect.xRight = MAX_INT;
  2926.       WinDrawText(hps, -1, pUCMI->pszText, &Rect, 0L, 0L, DT_QUERYEXTENT|DT_CENTER|DT_VCENTER|DT_TEXTATTRS|DT_MNEMONIC);
  2927.       *pHeight = Rect.yTop - Rect.yBottom;
  2928.       *pWidth  = (Rect.xRight - Rect.xLeft) + SUM_TEXT_FRAME_THICK_HORZ;
  2929.  
  2930.    // GpiQueryTextBox( hps,
  2931.    //                  strlen( pUCMI->pszText ),
  2932.    //                  pUCMI->pszText,
  2933.    //                  TXTBOX_COUNT,
  2934.    //                  aptl );
  2935.       WinReleasePS(hps);
  2936.    // *pHeight = aptl[TXTBOX_TOPLEFT].y  - aptl[TXTBOX_BOTTOMLEFT].y;
  2937.    // *pWidth  = aptl[TXTBOX_TOPRIGHT].x - aptl[TXTBOX_TOPLEFT].x;
  2938.    // *pWidth += SUM_TEXT_FRAME_THICK_HORZ;  // we leave some space around the text
  2939.    } else {
  2940.       *pHeight = 0;
  2941.       *pWidth  = 0;
  2942.    } // endif
  2943. }
  2944.  
  2945. //----------------------------------------------------------------------------
  2946. // UCMenuFreeMenuData
  2947. //----------------------------------------------------------------------------
  2948. // :function res=&IDF_FREEMENU. name='UCMenuFreeMenuData' text='Frees the menu data'.
  2949. // This function frees the data associated with the OWNERDRAW items of a menu.
  2950. // :syntax name='UCMenuFreeMenuData' params='hwndMenu' return='-' .
  2951. // :fparams.
  2952. // :fparam name='hwndMenu' type='HWND' io='input' .
  2953. // Menu window handle.
  2954. // :freturns.
  2955. // :fparam name='-' type='VOID' io='-'.
  2956. // Nothing.
  2957. // :efparams.
  2958. // :remarks.
  2959. // This function parses the whole menu (including submenus). It frees the
  2960. // data structure associated with every OWNERDRAW item.
  2961. // :p.This function requires the owner of the menu to be the ucmenu.
  2962. // :hp2.Note&colon.:ehp2. This function is automatically executed when a UCMenu receives a WM_DESTROY message.
  2963. // :enote.
  2964. // :related.
  2965. // :efunction.
  2966. //----------------------------------------------------------------------------
  2967. VOID APIENTRY  UCMenuFreeMenuData(HWND hwndMenu)
  2968. {
  2969.   MENUITEM mi;
  2970.   SHORT    sIndex, ItemID, NbOfItems;
  2971.   PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwndMenu, QWL_USER );
  2972.   HWND     hwndUCM;
  2973.  
  2974.   if ( UCMData ) {
  2975.      hwndUCM = WinQueryWindow( UCMData->hwndMenu, QW_OWNER );
  2976.   } else {
  2977.      hwndUCM = WinQueryWindow( hwndMenu, QW_OWNER );
  2978.   } /* endif */
  2979.  
  2980.   /*┌────────────────────────────────┐
  2981.     │ Query the Number of menu items │
  2982.     └────────────────────────────────┘*/
  2983.   NbOfItems = (SHORT)WinSendMsg(hwndMenu,
  2984.                                 MM_QUERYITEMCOUNT,
  2985.                                 (MPARAM)0,
  2986.                                 (MPARAM)0);
  2987.  
  2988.   for (sIndex=0 ; sIndex<NbOfItems ; sIndex++) {
  2989.  
  2990.     /*┌─────────────────────────────────────┐
  2991.       │ Query the item handle and structure │
  2992.       └─────────────────────────────────────┘*/
  2993.     ItemID = (SHORT)WinSendMsg(hwndMenu,
  2994.                                MM_ITEMIDFROMPOSITION,
  2995.                                MPFROMSHORT(sIndex),
  2996.                                (MPARAM)0);
  2997.     WinSendMsg( WinQueryWindow( hwndUCM, QW_OWNER ),
  2998.                 WM_CONTROL,
  2999.                 MPFROM2SHORT( WinQueryWindowUShort( hwndUCM, QWS_ID ), UCN_DELETEDITEM ),
  3000.                 MPFROMSHORT( ItemID ) );
  3001.     WinSendMsg(hwndMenu,
  3002.                MM_QUERYITEM,
  3003.                MPFROM2SHORT(ItemID,FALSE),
  3004.                MPFROMP(&mi));
  3005.  
  3006.     /*┌─────────────────────────────────────────────────────────┐
  3007.       │ If it's a Submenu, do a recursive call with hwndSubMenu │
  3008.       └─────────────────────────────────────────────────────────┘*/
  3009.     if (mi.hwndSubMenu){
  3010.        PFNWP pFnwp;
  3011.        UCMenuFreeMenuData(mi.hwndSubMenu);
  3012.        pFnwp = (PFNWP)WinQueryWindowPtr( mi.hwndSubMenu, QWP_PFNWP );
  3013.        if ( ( pFnwp == SubmenuWndProc ) && UCMData && UCMData->OldSubMenuProc ){
  3014.           WinSubclassWindow( mi.hwndSubMenu, (PFNWP)UCMData->OldSubMenuProc );
  3015.        } // endif
  3016.     } // endif
  3017.  
  3018.     /*┌─────────────────────────────────────┐
  3019.       │ Free the handle of ownerdrawn items │
  3020.       └─────────────────────────────────────┘*/
  3021.     if ((mi.afStyle & MIS_OWNERDRAW) && mi.hItem) {
  3022.       if ( ITEM( &mi, pszBmp ) ){
  3023.         MyFree( ITEM( &mi, pszBmp ) );
  3024.         ITEM( &mi, pszBmp ) = 0;
  3025.       }
  3026.       if ( ITEM( &mi, pszText ) ){
  3027.         MyFree( ITEM( &mi, pszText ) );
  3028.         ITEM( &mi, pszText ) = 0;
  3029.       }
  3030.       if ( ITEM( &mi, pszAction ) ){
  3031.         MyFree( ITEM( &mi, pszAction ) );
  3032.         ITEM( &mi, pszAction ) = 0;
  3033.       }
  3034.       if ( ITEM( &mi, pszData ) ){
  3035.         MyFree( ITEM( &mi, pszData ) );
  3036.         ITEM( &mi, pszData ) = 0;
  3037.       }
  3038.       if ( ITEM( &mi, pszParameters ) ){
  3039.         MyFree( ITEM( &mi, pszParameters ) );
  3040.         ITEM( &mi, pszParameters ) = 0;
  3041.       }
  3042.       if ( ITEM( &mi, hBmp ) ){
  3043.         GpiDeleteBitmap( ITEM( &mi, hBmp ) );
  3044.         ITEM( &mi, hBmp ) = 0;
  3045.       }
  3046.       MyFree( (PVOID)mi.hItem );
  3047.       mi.hItem = 0;
  3048.       WinSendMsg( hwndMenu,
  3049.                   MM_SETITEM,
  3050.                   MPFROM2SHORT( 0, TRUE ),
  3051.                   MPFROMP( &mi ) );
  3052.     } /* endif */
  3053.  
  3054.   } /* endfor */
  3055.  
  3056. }
  3057.  
  3058. //----------------------------------------------------------------------------
  3059. // CreateUCMenu : Internal function
  3060. //----------------------------------------------------------------------------
  3061. // :pfunction res=&IDF_CREATUCM. name='CreateUCMenu' text='Creates a User-customizable Menu'.
  3062. // This function creates a User-customizable Menu of the specified style in a given rectangle.
  3063. // :syntax name='CreateUCMenu' params='hwndUCMenu, hwndParent, hwndOwner, hwndMenu, hModule, MenuID, pRcl, Style, NbOfCols, NbOfRows' return='-'.
  3064. // :fparams.
  3065. // :fparam name='hwndUCMenu' type='HWND' io='input'.
  3066. // Handle of the UCMenu.
  3067. // :fparam name='hwndParent' type='HWND' io='input'.
  3068. // Handle of the UCMenu's parent window.
  3069. // :fparam name='hwndOwner' type='HWND' io='input'.
  3070. // Handle of the UCMenu's owner window.
  3071. // :fparam name='hwndMenu' type='HWND' io='input'.
  3072. // Handle of the menu window associated with the UCMenu.
  3073. // :fparam name='MenuID' type='USHORT' io='input'.
  3074. // ID of the menu in the resource
  3075. // :fparam name='pRcl' type='PRECTL' io='input'.
  3076. // UCMenu rectangle.
  3077. // p.The height of a horizontal ucmenu is the height of the tallest item
  3078. // p.The width of a vertical ucmenu is the width of the widest item
  3079. // p.The size of a matrix ucmenu is calculated according to NbOfCols, NbOfRows, the widest and tallest items
  3080. // :fparam name='Style' type='USHORT' io='input'.
  3081. // :dl compact.
  3082. // :dt.:hp2.CMS_VERT:ehp2.
  3083. // :dd.Vertical UCMenu
  3084. // :dt.:hp2.CMS_HORZ:ehp2.
  3085. // :dd.Horizontal UCMenu
  3086. // :dt.:hp2.CMS_MATRIX:ehp2.
  3087. // :dd.Matrix UCMenu
  3088. // :edl.
  3089. // :fparam name='NbOfCols' type='USHORT io='input'.
  3090. // Number of columns if matrix ucmenu
  3091. // :fparam name='NbOfRows' type='USHORT io='input'.
  3092. // Number of rows if matrix ucmenu
  3093. // :fparam name='ulVersion' type='ULONG io='input'.
  3094. // Template version used to build the menu
  3095. // :freturns.
  3096. // :fparam name='-' type='-' io='-'.
  3097. // Nothing.
  3098. // :efparams.
  3099. // :remarks.
  3100. // The UCMenu is the owner of the menu window and therefore receives all the messages.
  3101. // However, it forwards the following messages to its owner. They are
  3102. // described in PM Reference Guide (Menu Control Notification Messages).
  3103. // :dl compact.
  3104. // :dt.:hp2.WM_COMMAND:ehp2.
  3105. // :dd.:hp2.SHORT2FROMMP(mp1) = UCMenuID, SHORT1FROMMP(mp2) = CMDSRC_UCMENU:ehp2.
  3106. // :dt.:hp2.WM_HELP:ehp2.
  3107. // :dd.:hp2.SHORT2FROMMP(mp1) = UCMenuID, SHORT1FROMMP(mp2) = CMDSRC_UCMENU:ehp2.
  3108. // :dt.:hp2.WM_INITMENU:ehp2.
  3109. // :dd.
  3110. // :dt.:hp2.WM_MENUEND:ehp2.
  3111. // :dd.:hp2.mp2 = hwndUCMenu:ehp2.
  3112. // :dt.:hp2.WM_MENUSELECT:ehp2.
  3113. // :dd.:hp2.mp2 = hwndUCMenu:ehp2.
  3114. // :dt.:hp2.WM_NEXTMENU:ehp2.
  3115. // :dd.
  3116. // :edl.
  3117. // :p.
  3118. // The items for which a bitmap can not be found are processed like regular menu items. This
  3119. // means that the parameters associated to the previous messages are not changed for them.
  3120. // :p.
  3121. // The following messages are processed by the UCMenu and not forwarded &colon.
  3122. // :dl compact.
  3123. // :dt.:hp2.WM_DRAWITEM:ehp2.
  3124. // :dd.
  3125. // :dt.:hp2.WM_MEASUREITEM:ehp2.
  3126. // :dd.
  3127. // :edl.
  3128. // :p.
  3129. // The Menu Control Window Messages (MM_*) sent to the UCMenu are forwarded to
  3130. // the menu window. :hp2.MM_QUERYITEMTEXT:ehp2., :hp2.MM_QUERYITEMTEXTLENGTH:ehp2.
  3131. // and :hp2.MM_SETITEMTEXT:ehp2., which usually only work for items with a MIS_TEXT style, can
  3132. // be used with the MIS_OWNERDRAW items to query and set the text displayed in the bitmap.
  3133. // :xamples.
  3134. // :related.
  3135. // :epfunction.
  3136. //----------------------------------------------------------------------------
  3137. VOID _Optlink  CreateUCMenu(HWND hwndUCMenu, HWND hwndParent, HWND hwndOwner,
  3138.                            HWND hwndMenu, USHORT MenuID,
  3139.                            PRECTL prcl, USHORT Style, USHORT NbOfCols, USHORT NbOfRows, ULONG ulVersion)
  3140. {
  3141.   LONG      Arrow;
  3142.   RECTL     rcl, rclM;
  3143.   BOOL      Scrollable;
  3144.   PUCMDATA  UCMData;
  3145.   ULONG     ScrollStyle;
  3146.  
  3147.  
  3148.   UCMData = (PUCMDATA)WinQueryWindowULong(hwndUCMenu, QWL_UCMDATA);
  3149.  
  3150.   /*┌───────────────────────────┐
  3151.     │ Load the OWNERDRAWN items │
  3152.     └───────────────────────────┘*/
  3153.   UCMData->AccelTable->cAccel = 0;
  3154.  
  3155.   UCMenuLoadMenuData(hwndMenu, UCMData, ulVersion, hwndUCMenu );
  3156.  
  3157.   WinSetOwner (hwndMenu, hwndUCMenu);
  3158.  
  3159.   UCMenuNotifAll( UCMData, hwndMenu, UCN_ADDEDITEM );
  3160.  
  3161.   /*┌─────────────────────────────────────────────────────────────┐
  3162.     │ Autosize : take the size of the biggest item as a reference │
  3163.     └─────────────────────────────────────────────────────────────┘*/
  3164.  
  3165.     GetMaxItemSize(UCMData, hwndUCMenu, hwndMenu);
  3166.  
  3167.     if (Style & CMS_MATRIX) {
  3168.         prcl->yTop  = prcl->yBottom + (UCMData->MaxHorizontalHeight) * NbOfRows;
  3169.         prcl->yTop += SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  3170.         prcl->xRight  = prcl->xLeft + (UCMData->MaxVerticalWidth) * NbOfCols;
  3171.         prcl->xRight += SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  3172.     } // endif
  3173.  
  3174.     if ( Style & CMS_VERT ) {
  3175.       prcl->xRight = prcl->xLeft + UCMData->MaxVerticalWidth;
  3176.       prcl->xRight += SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  3177.     } // endif
  3178.  
  3179.     if ( Style & CMS_HORZ ) {
  3180.       prcl->yTop  = prcl->yBottom + UCMData->MaxHorizontalHeight;
  3181.       prcl->yTop += SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  3182.     } // endif
  3183.  
  3184.  
  3185.   /*┌──────────────────┐
  3186.     │ Size the UC Menu │
  3187.     └──────────────────┘*/
  3188.   WinSetWindowPos(hwndUCMenu,
  3189.                   HWND_TOP,
  3190.                   prcl->xLeft,
  3191.                   prcl->yBottom,
  3192.                   prcl->xRight - prcl->xLeft,
  3193.                   prcl->yTop - prcl->yBottom,
  3194.                   SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
  3195.  
  3196.   /*┌───────────────────┐
  3197.     │ Create Scroll Bar │
  3198.     └───────────────────┘*/
  3199.   ScrollStyle = SBS_HORZ;
  3200.   if ((Style & CMS_VERT) || ((Style & CMS_MATRIX_VERT) == CMS_MATRIX_VERT))
  3201.     ScrollStyle = SBS_VERT;
  3202.   UCMData->hwndScroll = WinCreateWindow(hwndUCMenu,
  3203.                                WC_SCROLLBAR,
  3204.                                "",
  3205.                                WS_VISIBLE | WS_CLIPCHILDREN | ScrollStyle,
  3206.                                0,
  3207.                                0,
  3208.                                prcl->xRight - prcl->xLeft,
  3209.                                prcl->yTop - prcl->yBottom,
  3210.                                hwndUCMenu,
  3211.                                HWND_TOP,
  3212.                                0,
  3213.                                NULL,
  3214.                                NULL);
  3215.  
  3216.   /*┌─────────────────────────────────────────────────┐
  3217.     │ Register and create a window to hide the slider │
  3218.     └─────────────────────────────────────────────────┘*/
  3219.   WinRegisterClass((HAB)NULLHANDLE, "Hide", (PFNWP)HideWndProc, (ULONG)CS_SIZEREDRAW, 4);
  3220.  
  3221.   UCMData->hwndHide = WinCreateWindow(UCMData->hwndScroll,
  3222.                              "Hide",
  3223.                              "",
  3224.                              WS_VISIBLE,
  3225.                              0,0,0,0,
  3226.                              hwndUCMenu,
  3227.                              HWND_TOP,
  3228.                              0,
  3229.                              (PVOID)WinQueryWindowULong(hwndUCMenu, QWL_UCMDATA),
  3230.                              (PVOID)NULL);
  3231.  
  3232.   WinSetParent(hwndMenu, UCMData->hwndHide, FALSE);
  3233.  
  3234.   switch (Style & 0x7) {
  3235.  
  3236.     case CMS_VERT:
  3237.       /*┌────────────────────────────────────────────────────────────────┐
  3238.         │ Get the menu height to know if we have to hide the buttons too:│
  3239.         │  - Set the width of the menu window and query its height       │
  3240.         └────────────────────────────────────────────────────────────────┘*/
  3241.       WinSetWindowPos(hwndMenu,
  3242.                       HWND_TOP,
  3243.                       0,
  3244.                       0,
  3245.                       UCMData->MaxVerticalWidth,
  3246.                       10000,
  3247.                       SWP_SIZE);
  3248.       WinQueryWindowRect(hwndMenu, &rclM);
  3249.       // The height returned is the sum  of all the items heights + 1
  3250.       //  ( don't ask me why ... )
  3251.       rclM.yTop --;
  3252.       WinSetWindowPos(hwndMenu,
  3253.                       HWND_TOP,
  3254.                       0,
  3255.                       0,
  3256.                       rclM.xRight,
  3257.                       rclM.yTop,
  3258.                       SWP_SIZE);
  3259.  
  3260.  
  3261.       /*┌──────────────────────┐
  3262.         │ Size the Hide Window │
  3263.         └──────────────────────┘*/
  3264.       Arrow = WinQuerySysValue(HWND_DESKTOP, SV_CYVSCROLLARROW);
  3265.       Scrollable = (rclM.yTop > (prcl->yTop - prcl->yBottom - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK));
  3266.       WinSetWindowPos(UCMData->hwndHide,
  3267.                       HWND_TOP,
  3268.                       UCM_FRAME_THICK,
  3269.                       UCM_FRAME_THICK + Arrow * Scrollable,
  3270.                       prcl->xRight - prcl->xLeft   - SUM_UCM_FRAME_THICK,
  3271.                       prcl->yTop   - prcl->yBottom - SUM_UCM_FRAME_THICK - 2 * Arrow * Scrollable,
  3272.                       SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
  3273.  
  3274.       /*┌─────────────────────────────────────────────────────┐
  3275.         │Set the scrollbar parameters : slider size and range │
  3276.         └─────────────────────────────────────────────────────┘*/
  3277.       WinQueryWindowRect(UCMData->hwndHide, &rcl);
  3278.       WinSendMsg(UCMData->hwndScroll,
  3279.                  SBM_SETSCROLLBAR,
  3280.                  MPFROMSHORT(0),
  3281.                  MPFROM2SHORT(0, rclM.yTop - (rcl.yTop - rcl.yBottom - SUM_MENU_FRAME_THICK)));
  3282.       WinSendMsg(UCMData->hwndScroll,
  3283.                  SBM_SETTHUMBSIZE,
  3284.                  MPFROM2SHORT(rcl.yTop - rcl.yBottom - SUM_MENU_FRAME_THICK, rclM.yTop),
  3285.                  (MPARAM)0);
  3286.  
  3287.       /*┌────────────────────────────┐
  3288.         │ Position and show the menu │
  3289.         └────────────────────────────┘*/
  3290.       WinSetWindowPos(hwndMenu,
  3291.                       HWND_TOP,
  3292.                       MENU_FRAME_THICK,
  3293.                       (rcl.yTop - rcl.yBottom - SUM_MENU_FRAME_THICK) - rclM.yTop  + MENU_FRAME_THICK,
  3294.                       0,
  3295.                       0,
  3296.                       SWP_MOVE | SWP_SHOW);
  3297.       break;
  3298.  
  3299.     case CMS_HORZ:
  3300.       /*┌────────────────────────────────────────────────────────────────┐
  3301.         │ Get the menu  width to know if we have to hide the buttons too:│
  3302.         │  - Query all items ...                                         │
  3303.         └────────────────────────────────────────────────────────────────┘*/
  3304.       { SHORT sIndex, NbOfItems, ItemID2, MenuWidth=0;
  3305.         RECTL rclItem;
  3306.  
  3307.         /*┌────────────────────────────────┐
  3308.           │ Query the Number of menu items │
  3309.           └────────────────────────────────┘*/
  3310.         NbOfItems = (SHORT)WinSendMsg(hwndMenu,
  3311.                                       MM_QUERYITEMCOUNT,
  3312.                                       (MPARAM)0,
  3313.                                       (MPARAM)0);
  3314.  
  3315.         for (sIndex=0 ; sIndex<NbOfItems ; sIndex++) {
  3316.           /*┌─────────────────────────────────────────────────────────┐
  3317.             │ Query the item rectangle and add the width to MenuWidth │
  3318.             └─────────────────────────────────────────────────────────┘*/
  3319.           ItemID2 = (SHORT)WinSendMsg(hwndMenu,
  3320.                                       MM_ITEMIDFROMPOSITION,
  3321.                                       MPFROMSHORT(sIndex),
  3322.                                       (MPARAM)0);
  3323.           WinSendMsg(hwndMenu,
  3324.                      MM_QUERYITEMRECT,
  3325.                      MPFROM2SHORT(ItemID2,FALSE),
  3326.                      MPFROMP(&rclItem));
  3327.  
  3328.           MenuWidth += rclItem.xRight - rclItem.xLeft;
  3329.         } /* endfor */
  3330.  
  3331.         /*┌──────────────────────┐
  3332.           │ Size the menu window │
  3333.           └──────────────────────┘*/
  3334.         WinSetWindowPos(hwndMenu,
  3335.                         HWND_TOP,
  3336.                         0,
  3337.                         0,
  3338.                         MenuWidth,
  3339.                         UCMData->MaxHorizontalHeight,
  3340.                         SWP_SIZE);
  3341.       }
  3342.  
  3343.       WinQueryWindowRect(hwndMenu, &rclM);
  3344.  
  3345.       /*┌──────────────────────┐
  3346.         │ Size the Hide Window │
  3347.         └──────────────────────┘*/
  3348.       Arrow = WinQuerySysValue(HWND_DESKTOP, SV_CXHSCROLLARROW);
  3349.       Scrollable = (rclM.xRight > (prcl->xRight - prcl->xLeft - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK));
  3350.       WinSetWindowPos(UCMData->hwndHide,
  3351.                       HWND_TOP,
  3352.                       UCM_FRAME_THICK + Arrow * Scrollable,
  3353.                       UCM_FRAME_THICK,
  3354.                       prcl->xRight - prcl->xLeft - SUM_UCM_FRAME_THICK - 2 * Arrow * Scrollable,
  3355.                       prcl->yTop - prcl->yBottom - SUM_UCM_FRAME_THICK,
  3356.                       SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
  3357.  
  3358.       /*┌─────────────────────────────────────────────────────┐
  3359.         │Set the scrollbar parameters : slider size and range │
  3360.         └─────────────────────────────────────────────────────┘*/
  3361.       WinQueryWindowRect(UCMData->hwndHide, &rcl);
  3362.       WinSendMsg(UCMData->hwndScroll,
  3363.                  SBM_SETSCROLLBAR,
  3364.                  MPFROMSHORT(0),
  3365.                  MPFROM2SHORT(0, rclM.xRight - (rcl.xRight - rcl.xLeft - SUM_MENU_FRAME_THICK)));
  3366.       WinSendMsg(UCMData->hwndScroll,
  3367.                  SBM_SETTHUMBSIZE,
  3368.                  MPFROM2SHORT(rcl.xRight - rcl.xLeft - SUM_MENU_FRAME_THICK, rclM.xRight),
  3369.                  (MPARAM)0);
  3370.  
  3371.       /*┌────────────────────────────┐
  3372.         │ Position and show the menu │
  3373.         └────────────────────────────┘*/
  3374.       WinSetWindowPos(hwndMenu,
  3375.                       HWND_TOP,
  3376.                       MENU_FRAME_THICK,
  3377.                       MENU_FRAME_THICK,
  3378.                       0,
  3379.                       0,
  3380.                       SWP_MOVE | SWP_SHOW);
  3381.       break;
  3382.  
  3383.     case CMS_MATRIX:
  3384.       WinSetWindowPos(hwndMenu,
  3385.                       HWND_TOP,
  3386.                       0,
  3387.                       0,
  3388.                       prcl->xRight - prcl->xLeft - SUM_MENU_FRAME_THICK - SUM_UCM_FRAME_THICK,
  3389.                       10000,
  3390.                       SWP_SIZE);
  3391.       WinQueryWindowRect(hwndMenu, &rclM);
  3392.  
  3393.       WinSetWindowPos(UCMData->hwndHide,
  3394.                       HWND_TOP,
  3395.                       UCM_FRAME_THICK,
  3396.                       UCM_FRAME_THICK,
  3397.                       prcl->xRight - prcl->xLeft - SUM_UCM_FRAME_THICK,
  3398.                       prcl->yTop - prcl->yBottom - SUM_UCM_FRAME_THICK,
  3399.                       SWP_MOVE | SWP_SIZE | SWP_SHOW );
  3400.  
  3401.       WinSetWindowPos(hwndMenu,
  3402.                       HWND_TOP,
  3403.                       MENU_FRAME_THICK,
  3404.                       prcl->yTop - prcl->yBottom - SUM_MENU_FRAME_THICK - SUM_UCM_FRAME_THICK - rclM.yTop + MENU_FRAME_THICK,
  3405.                       0,
  3406.                       0,
  3407.                       SWP_MOVE | SWP_ZORDER | SWP_SHOW);
  3408.  
  3409.       break;
  3410.   } /* endswitch */
  3411. }
  3412.  
  3413. //----------------------------------------------------------------------------
  3414. // UCMenuSize : Not for the user's doc
  3415. //----------------------------------------------------------------------------
  3416. // :pfunction res=&IDF_UCMenuSize. name='UCMenuSize' text='Resizes a menu window'.
  3417. // This function resizes the menu window of horizontal and vertical UCMenus.
  3418. // It is basically used when a user adds, removes or changes a bitmap.
  3419. // :syntax name='UCMenuSize' params='hwndMenu, Style' return='rc'.
  3420. // :fparams.
  3421. // :fparam name='hwndMenu' type='HWND' io='input'.
  3422. // Window handle of the menu.
  3423. // :fparam name='Style' type='LONG' io='input'.
  3424. // Style of the menu (CMS_HORZ or CMS_VERT).
  3425. // :freturns.
  3426. // :fparam name='rc' type='BOOL' io='output'.
  3427. // Returns :hp2.TRUE:ehp2. if the menu window is resized.
  3428. // :efparams.
  3429. // :remarks.
  3430. // This function recalculates the width of horizontal menus and the height of
  3431. // vertical menus by adding the bitmap sizes.
  3432. // :hp2.Note&colon.:ehp2. This function is automatically called by the UCMenu when it receives
  3433. // a MM_DELETEITEM, MM_REMOVEITEM, MM_INSERTITEM, MM_SETITEM, MM_SETITEMATTR
  3434. // or MM_SETITEMHANDLE message.
  3435. // :enote.
  3436. // :xamples.
  3437. // :related.
  3438. // :epfunction.
  3439. //----------------------------------------------------------------------------
  3440. BOOL _Optlink  UCMenuSize(HWND hwndMenu, USHORT Style)
  3441. {
  3442.   RECTL rcl;
  3443.   SHORT Size=0;
  3444.   SHORT NbOfItems, ItemID, sIndex;
  3445.   HWND  hwndHide;
  3446.   PUCMDATA UCMData ;
  3447.  
  3448.   UCMData = (PUCMDATA)WinQueryWindowULong(hwndMenu , QWL_USER);
  3449.  
  3450.   /*┌────────────────────────────────┐
  3451.     │ Query the Number of menu items │
  3452.     └────────────────────────────────┘*/
  3453.   NbOfItems = (SHORT)WinSendMsg(hwndMenu,
  3454.                                 MM_QUERYITEMCOUNT,
  3455.                                 (MPARAM)0,
  3456.                                 (MPARAM)0);
  3457.  
  3458.   for (sIndex=0 ; sIndex<NbOfItems ; sIndex++) {
  3459.     /*┌───────────────────────────────────────────────────┐
  3460.       │ Query the item rectangle and add its size to Size │
  3461.       └───────────────────────────────────────────────────┘*/
  3462.     ItemID = (SHORT)WinSendMsg(hwndMenu,
  3463.                                MM_ITEMIDFROMPOSITION,
  3464.                                MPFROMSHORT(sIndex),
  3465.                                (MPARAM)0);
  3466.     WinSendMsg(hwndMenu,
  3467.                MM_QUERYITEMRECT,
  3468.                MPFROM2SHORT(ItemID,FALSE),
  3469.                MPFROMP(&rcl));
  3470.  
  3471.     if (Style & CMS_HORZ)
  3472.       Size += rcl.xRight - rcl.xLeft;
  3473.     else
  3474.       Size += rcl.yTop - rcl.yBottom;
  3475.  
  3476.   }
  3477.  
  3478.   /*┌───────────────────────┐
  3479.     │ Invalidate the parent │
  3480.     └───────────────────────┘*/
  3481.   hwndHide = WinQueryWindow(hwndMenu, QW_PARENT);
  3482.   WinQueryWindowRect(hwndHide, &rcl);
  3483.   WinInvalidateRect(hwndHide, &rcl, TRUE);
  3484.  
  3485.   /*┌──────────────────────┐
  3486.     │ Size the menu window │
  3487.     └──────────────────────┘*/
  3488.   if (!(Style & CMS_MATRIX))
  3489.     WinSetWindowPos(hwndMenu,
  3490.                     HWND_TOP,
  3491.                     MENU_FRAME_THICK,
  3492.                     MENU_FRAME_THICK,
  3493.                     (Style & CMS_HORZ ? Size : UCMData->MaxVerticalWidth ),
  3494.                     (Style & CMS_VERT ? Size : UCMData->MaxHorizontalHeight),
  3495.                     SWP_SIZE);
  3496.   else
  3497.     WinSetWindowPos(hwndMenu,
  3498.                     HWND_TOP,
  3499.                     MENU_FRAME_THICK,
  3500.                     MENU_FRAME_THICK,
  3501.                     UCMData->MaxVerticalWidth    * UCMData->NbOfCols,
  3502.                     UCMData->MaxHorizontalHeight * UCMData->NbOfRows,
  3503.                     SWP_SIZE);
  3504.  
  3505.   return TRUE;
  3506. }
  3507.  
  3508. //----------------------------------------------------------------------------
  3509. // UCMenuCheckScrolling : Not for the user's doc
  3510. //----------------------------------------------------------------------------
  3511. // :pfunction res=&IDF_CHKSCROL. name='UCMenuCheckScrolling' text='Checks the scrolling status'.
  3512. // This function compares the menu size with the UCMenu size and enables or disables
  3513. // the scrolling.
  3514. // :syntax name='UCMenuCheckScrolling' params='hwndUCMenu' return='rc'.
  3515. // :fparams.
  3516. // :fparam name='hwndUCMenu' type='HWND' io='input'.
  3517. // Window handle of the UCMenu (as returned by CreateUCMenu).
  3518. // :freturns.
  3519. // :fparam name='rc' type='BOOL' io='output'.
  3520. // Returns :hp1.TRUE:ehp1. if the scrolling status changed.
  3521. // :efparams.
  3522. // :remarks.
  3523. // The parameters are reset in two cases &colon.
  3524. // :ol compact.
  3525. // :li.The menu is larger than the UCMenu and the scrolling disabled
  3526. // :li.The menu is shorter than the UCMenu and the scrolling enabled
  3527. // :eol.
  3528. // :note.This function is called every time the UCMenu receives a WM_SIZE
  3529. // message.
  3530. // :enote.
  3531. // :xamples.
  3532. // :related.
  3533. // :epfunction.
  3534. //----------------------------------------------------------------------------
  3535. BOOL _Optlink  UCMenuCheckScrolling(HWND hwndUCMenu)
  3536. {
  3537.   HWND      hwndScroll = WinQueryWindow(hwndUCMenu, QW_TOP);
  3538.   HWND      hwndHide   = WinQueryWindow(hwndScroll, QW_TOP);
  3539.   HWND      hwndMenu   = WinQueryWindow(hwndHide,   QW_TOP);
  3540.   LONG      Arrow      = WinQuerySysValue(HWND_DESKTOP, SV_CYVSCROLLARROW);
  3541.   ULONG     Style      = WinQueryWindowULong(hwndUCMenu, QWL_STYLE);
  3542.   SWP       swpMenu, swpHide, swpScroll;
  3543.  
  3544.   if (!Style)
  3545.     return FALSE;
  3546.  
  3547.   WinQueryWindowPos(hwndMenu,   &swpMenu);
  3548.   WinQueryWindowPos(hwndHide,   &swpHide);
  3549.   WinQueryWindowPos(hwndScroll, &swpScroll);
  3550.  
  3551.   if (((Style & CMS_VERT) || ((Style & CMS_MATRIX_VERT) == CMS_MATRIX_VERT)) &&
  3552.       swpMenu.cy >  swpScroll.cy - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK
  3553.       ) {
  3554.     SHORT     CurrPos;    //@XXXa
  3555.     CurrPos = (SHORT)WinSendMsg(hwndScroll, SBM_QUERYPOS, MPVOID, MPVOID);  //@XXXa
  3556.     /*┌──────────────────────────────────────────────────────────────────┐
  3557.       │ Menu larger than scrollbar. We reset the                         │
  3558.       │ whole thing : Resize the hiding window, reposition the menu      │
  3559.       │ window, reset the scrolling parameters                           │
  3560.       └──────────────────────────────────────────────────────────────────┘*/
  3561.  
  3562.     /* Adjust hide window to uncover scroll bar arrows */
  3563.     swpHide.y    += Arrow;
  3564.     swpHide.cy   -= 2 * Arrow;
  3565.  
  3566.     /* Adjust menu to current scroll position */
  3567.     swpMenu.y = (swpHide.cy - MENU_FRAME_THICK) - swpMenu.cy + CurrPos;
  3568.  
  3569.     // Adjust position of the menu window relative to the scrollbar window.  Position the
  3570.     // X coordinate to align the left edge of the menu into the scrollbar.  Leave the Y
  3571.     // coordinate where it is, or flush-top align it if it does not extend to the bottom.
  3572.  
  3573.     swpMenu.x = MENU_FRAME_THICK;
  3574. //  if (swpMenu.y + swpMenu.cy < swpHide.y + swpHide.cy - MENU_FRAME_THICK)  // Does not reach top?
  3575. //    swpMenu.y = (swpHide.y + swpHide.cy - MENU_FRAME_THICK) - swpMenu.cy;  // Align to top
  3576. //  else
  3577.       swpMenu.y = min(swpMenu.y, MENU_FRAME_THICK);         // Dont allow to lift off bottom
  3578.     WinSetWindowPos(hwndMenu,
  3579.                       HWND_TOP, swpMenu.x, swpMenu.y, 0, 0,
  3580.                       SWP_MOVE | SWP_SHOW | SWP_ZORDER);
  3581.  
  3582.     WinSetWindowPos(hwndHide,
  3583.                     HWND_TOP,
  3584.                     swpHide.x,
  3585.                     swpHide.y,
  3586.                     swpHide.cx,
  3587.                     swpHide.cy,
  3588.                     SWP_MOVE | SWP_SIZE | SWP_SHOW);
  3589.  
  3590.     /*┌──────────────────────────────┐
  3591.       │ Set the scrolling parameters │
  3592.       └──────────────────────────────┘*/
  3593.     WinSendMsg(hwndScroll,
  3594.                SBM_SETSCROLLBAR,
  3595.                MPFROMSHORT((swpMenu.y+swpMenu.cy)-(swpHide.cy-MENU_FRAME_THICK)),
  3596.                MPFROM2SHORT(0, swpMenu.cy - (swpHide.cy-SUM_MENU_FRAME_THICK)));
  3597.     WinSendMsg(hwndScroll,
  3598.                SBM_SETTHUMBSIZE,
  3599.                MPFROM2SHORT(swpHide.cy-SUM_MENU_FRAME_THICK, swpMenu.cy),
  3600.                (MPARAM)0);
  3601.   
  3602.     /*┌───────────────────────────────┐
  3603.       │ Window resized : return TRUE  │
  3604.       └───────────────────────────────┘*/
  3605.     return TRUE;
  3606.   } /* endif */
  3607.  
  3608.   if (((Style & CMS_VERT) || ((Style & CMS_MATRIX_VERT) == CMS_MATRIX_VERT)) &&
  3609.       swpMenu.cy <= swpScroll.cy - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK
  3610.       ) {
  3611.     /*┌──────────────────────────────────────────────────────────────────┐
  3612.       │ Menu smaller than scrollbar. We reset the                        │
  3613.       │ whole thing : Resize the hiding window, reposition the menu      │
  3614.       │ window, reset the scrolling parameters                           │
  3615.       └──────────────────────────────────────────────────────────────────┘*/
  3616.  
  3617.       // Reset menu to left/top flush edge
  3618.       WinSetWindowPos(hwndMenu,
  3619.                       HWND_TOP,
  3620.                       MENU_FRAME_THICK,
  3621.                       (swpHide.cy - MENU_FRAME_THICK) - swpMenu.cy,
  3622.                       0,
  3623.                       0,
  3624.                       SWP_MOVE | SWP_SHOW | SWP_ZORDER);
  3625.  
  3626.  
  3627.     /*┌──────────────────────────────┐
  3628.       │ Set the scrolling parameters │
  3629.       └──────────────────────────────┘*/
  3630.     WinSendMsg(hwndScroll,
  3631.                SBM_SETSCROLLBAR,
  3632.                MPFROMSHORT(0),
  3633.                MPFROM2SHORT(0, swpMenu.cy - (swpHide.cy-SUM_MENU_FRAME_THICK)));
  3634.     WinSendMsg(hwndScroll,
  3635.                SBM_SETTHUMBSIZE,
  3636.                MPFROM2SHORT(swpHide.cy-SUM_MENU_FRAME_THICK, swpMenu.cy),
  3637.                (MPARAM)0);
  3638.  
  3639.     return TRUE;
  3640.   } /* endif */
  3641.  
  3642.   if ((Style & CMS_HORZ) &&
  3643.       swpMenu.cx >  swpScroll.cx - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK
  3644.       ) {
  3645.  
  3646.     /*┌──────────────────────────────────────────────────────────────────┐
  3647.       │ Menu larger than scrollbar. We reset the                         │
  3648.       │ whole thing : Resize the hiding window, reposition the menu      │
  3649.       │ window, reset the scrolling parameters                           │
  3650.       └──────────────────────────────────────────────────────────────────┘*/
  3651.  
  3652.     /*┌───────────────────────────────────┐
  3653.       │ Resize Hide : width   -= 2 Arrows │
  3654.       │ Repos  Hide : xLeft   += Arrow    │
  3655.       └───────────────────────────────────┘*/
  3656.     swpHide.x  +=     Arrow;
  3657.     swpHide.cx -= 2 * Arrow;
  3658.  
  3659.     // Adjust position of the menu window relative to the scrollbar window.  Position the
  3660.     // Y coordinate to align the top edge of the menu into the scrollbar.  Leave the X
  3661.     // coordinate where it is, or flush-right align it if it does not extend to the edge.
  3662.  
  3663.     swpMenu.y = swpScroll.cy - (2*SUM_UCM_FRAME_THICK) - swpMenu.cy + MENU_FRAME_THICK;                         //@P5a
  3664.     swpMenu.x = max(swpMenu.x, swpScroll.x + swpScroll.cx - (2*Arrow) - swpMenu.cx - (2*SUM_MENU_FRAME_THICK)); //@P5a
  3665.     WinSetWindowPos(hwndMenu,                                                                                   //@P5m
  3666.                       HWND_TOP, swpMenu.x, swpMenu.y, 0, 0,                                                     //@P5m
  3667.                       SWP_MOVE | SWP_SHOW | SWP_ZORDER);                                                        //@P5m
  3668.  
  3669.     WinSetWindowPos(hwndHide,
  3670.                     HWND_TOP,
  3671.                     swpHide.x,
  3672.                     swpHide.y,
  3673.                     swpHide.cx,
  3674.                     swpHide.cy,
  3675.                     SWP_MOVE | SWP_SIZE | SWP_SHOW);
  3676.  
  3677.     /*┌──────────────────────────────┐
  3678.       │ Set the scrolling parameters │
  3679.       └──────────────────────────────┘*/
  3680.     WinSendMsg(hwndScroll,
  3681.                SBM_SETSCROLLBAR,
  3682.                MPFROMSHORT(swpScroll.x - swpMenu.x),  // Posn may have changed by move of menu above //@P5c
  3683.                MPFROM2SHORT(0, swpMenu.cx - (swpHide.cx-SUM_MENU_FRAME_THICK)));
  3684.     WinSendMsg(hwndScroll,
  3685.                SBM_SETTHUMBSIZE,
  3686.                MPFROM2SHORT(swpHide.cx-SUM_MENU_FRAME_THICK, swpMenu.cx),
  3687.                (MPARAM)0);
  3688.  
  3689.     /*┌───────────────────────────────┐
  3690.       │ Window resized : return TRUE  │
  3691.       └───────────────────────────────┘*/
  3692.     return TRUE;
  3693.   } /* endif */
  3694.  
  3695.   if ((Style & CMS_HORZ) &&
  3696.       swpMenu.cx <= swpScroll.cx - SUM_UCM_FRAME_THICK - SUM_MENU_FRAME_THICK
  3697.       ) {
  3698.     /*┌──────────────────────────────────────────────────────────────────┐
  3699.       │ Menu smaller than scrollbar. We reset the                        │
  3700.       │ whole thing : Resize the hiding window, reposition the menu      │
  3701.       │ window, reset the scrolling parameters                           │
  3702.       └──────────────────────────────────────────────────────────────────┘*/
  3703.  
  3704.       // Reset menu to left/top flush edge
  3705.       WinSetWindowPos(hwndMenu,                                                                 //@P5a
  3706.                       HWND_TOP,                                                                 //@P5a 
  3707.                       MENU_FRAME_THICK,                                                         //@P5a 
  3708.                       swpScroll.cy - (2*SUM_UCM_FRAME_THICK) - swpMenu.cy + MENU_FRAME_THICK,   //@P5a 
  3709.                       0, 0, SWP_MOVE | SWP_SHOW | SWP_ZORDER);                                  //@P5a 
  3710.  
  3711.     /*┌──────────────────────────────┐
  3712.       │ Set the scrolling parameters │
  3713.       └──────────────────────────────┘*/
  3714.     WinSendMsg(hwndScroll,
  3715.                SBM_SETSCROLLBAR,
  3716.                MPFROMSHORT(0),        // Scroll position is now zero (flush left)
  3717.                MPFROM2SHORT(0, swpMenu.cx - (swpHide.cx-SUM_MENU_FRAME_THICK)));
  3718.     WinSendMsg(hwndScroll,
  3719.                SBM_SETTHUMBSIZE,
  3720.                MPFROM2SHORT(swpHide.cx-SUM_MENU_FRAME_THICK, swpMenu.cx),
  3721.                (MPARAM)0);
  3722.  
  3723.     return TRUE;
  3724.   } else {
  3725.     /*┌─────────────────────┐
  3726.       │ Matrix, no scrolling│
  3727.       └─────────────────────┘*/
  3728.  
  3729.       // Reset menu to flush left/top
  3730.       WinSetWindowPos(hwndMenu, HWND_TOP,                                                       //@P5a
  3731.                       MENU_FRAME_THICK,                                                         //@P5a 
  3732.                       (swpHide.cy - MENU_FRAME_THICK) - swpMenu.cy,                             //@P5a
  3733.                       0, 0, SWP_MOVE | SWP_SHOW | SWP_ZORDER);                                  //@P5a 
  3734.  
  3735. //  WinSendMsg(hwndScroll,
  3736. //             SBM_SETSCROLLBAR,
  3737. //             MPFROMSHORT(0),
  3738. //             MPFROM2SHORT(0,0));
  3739. //  WinSendMsg(hwndScroll,
  3740. //             SBM_SETTHUMBSIZE,
  3741. //             MPFROM2SHORT(swpHide.cx-SUM_MENU_FRAME_THICK, swpMenu.cx),
  3742. //             (MPARAM)0);
  3743.     return TRUE;
  3744.   } /* endif */
  3745. }
  3746.  
  3747. //----------------------------------------------------------------------------
  3748. // UCMenuIdFromCoord :
  3749. //----------------------------------------------------------------------------
  3750. // :function res=&IDF_IDFROMP. name='UCMenuIdFromCoord' text='Get the ID of a specified menu item' .
  3751. // This function returns the id of the menu item that is at a specified position.
  3752. // :syntax name='UCMenuIdFromCoord' params='hwndMenu, pptrPos' return='ItemID' .
  3753. // :fparams.
  3754. // :fparam name='hwndMenu' type='HWND' io='input' .
  3755. // Menu window handle.
  3756. // :fparam name='pptrPos' type='PPOINTL' io='input' .
  3757. // Position
  3758. // :freturns.
  3759. // :fparam name='ItemID' type='USHORT' io='return'.
  3760. // The item Identifier. 0 if not found.
  3761. // :efparams.
  3762. // :remarks.
  3763. // This function doesn't check the submenus. However, you can identify an item in a submenu
  3764. // if you pass the hwnd of the submenu...
  3765. // :related.
  3766. // :efunction.
  3767. //----------------------------------------------------------------------------
  3768. USHORT APIENTRY  UCMenuIdFromCoord(HWND hwndMenu, PPOINTL pptrPos)
  3769. {
  3770.   USHORT    NbOfItems, ItemID, usIndex;
  3771.   RECTL    rcl;
  3772.  
  3773.   /*┌────────────────────────────────┐
  3774.     │ Query the Number of menu items │
  3775.     └────────────────────────────────┘*/
  3776.   NbOfItems = (USHORT)WinSendMsg(hwndMenu,
  3777.                                  MM_QUERYITEMCOUNT,
  3778.                                  (MPARAM)0,
  3779.                                  (MPARAM)0);
  3780.  
  3781.   for (usIndex=0 ; usIndex<NbOfItems ; usIndex++) {
  3782.     /*┌───────────────────┐
  3783.       │ Query the item id │
  3784.       └───────────────────┘*/
  3785.     ItemID = (USHORT)WinSendMsg(hwndMenu,
  3786.                                MM_ITEMIDFROMPOSITION,
  3787.                                MPFROMSHORT(usIndex),
  3788.                                (MPARAM)0);
  3789.  
  3790.     /*┌─────────────────────────┐
  3791.       │ Query the item rectangle│
  3792.       └─────────────────────────┘*/
  3793.     WinSendMsg(hwndMenu,
  3794.                MM_QUERYITEMRECT,
  3795.                MPFROM2SHORT(ItemID,TRUE),
  3796.                MPFROMP(&rcl));
  3797.  
  3798.     //(MAM) fixed following to include xRight and yTop pixels
  3799.     if (    pptrPos->x >= rcl.xLeft
  3800.          && pptrPos->x <= rcl.xRight
  3801.          && pptrPos->y >= rcl.yBottom
  3802.          && pptrPos->y <= rcl.yTop     ) {
  3803.       /*┌─────────────┐
  3804.         │ We got it ! │
  3805.         └─────────────┘*/
  3806.       return ItemID;
  3807.      } // endif;
  3808.   } // endfor
  3809.   return 0;
  3810. }
  3811.  
  3812. //----------------------------------------------------------------------------
  3813. // UCMenuGetActionID
  3814. //----------------------------------------------------------------------------
  3815. // :function res=&IDF_IDFROMACTION. name='UCMenuGetActionID' text='Get the IDs corresponding to an action' .
  3816. // This function returns the ID of the item with a pszAction action, starting at the item sStart.
  3817. // :syntax name='UCMenuGetActionID' params='hwndUCM, pszAction, , bSubmenus, sStart ' return='FoundID' .
  3818. // :fparams.
  3819. // :fparam name='hwndUCM' type='HWND' io='input' .
  3820. // UCMenu window handle.
  3821. // :fparam name='pszAction' type='PSZ' io='input' .
  3822. // Action string to look for
  3823. // :fparam name='bSubmenus' type='BOOL' io='input' .
  3824. // Look in submenus or not.
  3825. // :fparam name='Start' type='SHORT' io='input' .
  3826. // Item ID to start with, MIT_FIRST for the beginning.
  3827. // :freturns.
  3828. // :fparam name='FoundID' type='SHORT' io='return'.
  3829. // Item ID found, or MIT_NONE
  3830. // :efparams.
  3831. // :remarks.
  3832. // :related.
  3833. // :efunction.
  3834. //----------------------------------------------------------------------------
  3835. SHORT APIENTRY UCMenuGetActionID(HWND hwndUCM, PSZ pszAction, BOOL bSubmenus, SHORT sStartID)
  3836. {
  3837.    SHORT    sFound;
  3838.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndUCM, QWL_UCMDATA );
  3839.  
  3840.    if ( UCMData ) {
  3841.       sFound =  UCMenuGetActionID2( UCMData->hwndMenu, pszAction, bSubmenus, sStartID );
  3842.       if ( sFound == -2 ){
  3843.          return MIT_NONE;
  3844.       } else {
  3845.          return sFound;
  3846.       } // endif
  3847.    } else {
  3848.       return MIT_NONE;
  3849.    } /* endif */
  3850. }
  3851.  
  3852.  
  3853. //----------------------------------------------------------------------------
  3854. // UCMenuGetActionID2
  3855. //----------------------------------------------------------------------------
  3856. // :pfunction res=&IDF_IDFROMACTION2. name='UCMenuGetActionID2' text='Get the IDs corresponding to an action'.
  3857. // This function returns the ID of the item with a pszAction action, starting at the item sStart.
  3858. // :syntax name='UCMenuGetActionID2' params='hwndUCM, pszAction, , bSubmenus, sStart ' return='FoundID' .
  3859. // :fparams.
  3860. // :fparam name='hwndMenu' type='HWND' io='input' .
  3861. // Menu window handle.
  3862. // :fparam name='pszAction' type='PSZ' io='input' .
  3863. // Action string to look for
  3864. // :fparam name='bSubmenus' type='BOOL' io='input' .
  3865. // Look in submenus or not.
  3866. // :fparam name='Start' type='SHORT' io='input' .
  3867. // Item ID to start with, MIT_FIRST for the beginning.
  3868. // :freturns.
  3869. // :fparam name='FoundID' type='SHORT' io='return'.
  3870. // Item ID found, or MIT_NONE if none, -2 if sStart has been found
  3871. // :efparams.
  3872. // :remarks.
  3873. // :related.
  3874. // :epfunction.
  3875. //----------------------------------------------------------------------------
  3876.  
  3877. SHORT _Optlink UCMenuGetActionID2(HWND hwndMenu, PSZ pszAction, BOOL bSubmenus, SHORT sStartID)
  3878. {
  3879.   USHORT    NbOfItems, ItemID, usIndex;
  3880.   BOOL      bStartIDPassed;
  3881.   MENUITEM  mi;
  3882.  
  3883.   if ( sStartID == MIT_FIRST ){
  3884.      bStartIDPassed = TRUE;
  3885.   } else {
  3886.      bStartIDPassed = FALSE;
  3887.   } // endif
  3888.  
  3889.   /*┌────────────────────────────────┐
  3890.     │ Query the Number of menu items │
  3891.     └────────────────────────────────┘*/
  3892.   NbOfItems = (USHORT)WinSendMsg(hwndMenu,
  3893.                                  MM_QUERYITEMCOUNT,
  3894.                                  (MPARAM)0,
  3895.                                  (MPARAM)0);
  3896.  
  3897.   for (usIndex=0 ; usIndex<NbOfItems ; usIndex++) {
  3898.     /*┌───────────────────┐
  3899.       │ Query the item id │
  3900.       └───────────────────┘*/
  3901.     memset( &mi, '\0', sizeof mi );
  3902.     ItemID = (USHORT)WinSendMsg(hwndMenu,
  3903.                                MM_ITEMIDFROMPOSITION,
  3904.                                MPFROMSHORT(usIndex),
  3905.                                (MPARAM)0);
  3906.  
  3907.     /*┌────────────────┐
  3908.       │ Query the item │
  3909.       └────────────────┘*/
  3910.     WinSendMsg(hwndMenu,
  3911.                MM_QUERYITEM,
  3912.                MPFROM2SHORT(ItemID,FALSE),
  3913.                MPFROMP(&mi));
  3914.     if ( bStartIDPassed ){
  3915.        if ( mi.hItem && ITEM( &mi, pszAction ) ){
  3916.           if ( !strcmp( pszAction, ITEM( &mi, pszAction ) ) ){
  3917.              return ItemID;
  3918.           } // endif
  3919.        } // endif
  3920.     } // endif
  3921.  
  3922.     if ( bSubmenus && mi.hwndSubMenu ){
  3923.        SHORT sFoundID =
  3924.           UCMenuGetActionID2( mi.hwndSubMenu, pszAction, FALSE, bStartIDPassed?MIT_FIRST:sStartID);
  3925.        if ( sFoundID != MIT_NONE  && sFoundID != -2){
  3926.           return sFoundID;
  3927.        } else if ( sFoundID == -2 ){
  3928.           bStartIDPassed = TRUE;
  3929.        } // endif
  3930.     } // endif
  3931.  
  3932.     if ( ItemID == sStartID ){
  3933.        bStartIDPassed = TRUE;
  3934.     } // endif
  3935.  
  3936.   } // endfor
  3937.  
  3938.   if ( bStartIDPassed ){
  3939.      return -2;
  3940.   } else {
  3941.      return MIT_NONE;
  3942.   } // endif
  3943. }
  3944.  
  3945. //----------------------------------------------------------------------------
  3946. // UCMenuSetActionAttr
  3947. //----------------------------------------------------------------------------
  3948. // :function res=&IDF_SETACTIONATTR. name='UCMenuSetActionAttr' text='Get the IDs corresponding to an action' .
  3949. // This function sets the attributes of the items with the given action.
  3950. // :syntax name='UCMenuSetActionAttr' params='hwndUCM, pszAction, usAttrMask, usAttrValue' return='nothing' .
  3951. // :fparams.
  3952. // :fparam name='hwndUCM' type='HWND' io='input' .
  3953. // UCMenu window handle.
  3954. // :fparam name='pszAction' type='PSZ' io='input' .
  3955. // Action string to look for
  3956. // :fparam name='usAttrMask' type='USHORT' io='input' .
  3957. // Attribute mask to use
  3958. // :fparam name='usAttrValue' type='USHORT' io='input' .
  3959. // Attribute value to set
  3960. // :freturns.
  3961. // :fparam name='-' type='VOID' io='return'.
  3962. // Nothing
  3963. // :efparams.
  3964. // :remarks.
  3965. // :related.
  3966. // MM_SETITEMATTR
  3967. // :efunction.
  3968. //----------------------------------------------------------------------------
  3969. VOID APIENTRY UCMenuSetActionAttr(HWND hwndUCM, PSZ pszAction, USHORT usAttrMask, USHORT usAttrValue )
  3970. {
  3971.    SHORT sIndex = MIT_FIRST;
  3972.    sIndex =  UCMenuGetActionID( hwndUCM, pszAction, TRUE, sIndex );
  3973.    while ( sIndex != MIT_NONE ){
  3974.       WinSendMsg( hwndUCM, MM_SETITEMATTR, MPFROM2SHORT( sIndex, TRUE ), MPFROM2SHORT( usAttrMask, usAttrValue ) );
  3975.       sIndex =  UCMenuGetActionID( hwndUCM, pszAction, TRUE, sIndex );
  3976.    } // endwhile
  3977. }
  3978.  
  3979.  
  3980. //----------------------------------------------------------------------------
  3981. // UCMenuContextMenu : Not for the user's doc
  3982. //----------------------------------------------------------------------------
  3983. // :pfunction res=&IDF_CTXTMENU. name='UCMenuContextMenu' text='Popups the context menu' .
  3984. // This function popups the appropriate context menu accroding to the mouse location
  3985. // :syntax name='UCMenuContextMenu' params='hwndUCMenu, hwndMenu, FromMouse' return='-' .
  3986. // :fparams.
  3987. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  3988. // UCMenu window handle.
  3989. // :fparam name='hwndMenu' type='HWND' io='input' .
  3990. // Menu window handle.
  3991. // :fparam name='FromMouse' type='BOOL' io='input' .
  3992. // Tells wether the CM was initiated from the mouse or not
  3993. // :freturns.
  3994. // :fparam name='-' type='VOID' io='-'.
  3995. // Nothing
  3996. // :efparams.
  3997. // :remarks.
  3998. // :related.
  3999. // :epfunction.
  4000. //----------------------------------------------------------------------------
  4001. VOID _Optlink UCMenuContextMenu(HWND hwndUCMenu, HWND hwndMenu, BOOL FromMouse)
  4002. { POINTL   ptl;
  4003.   MENUITEM mi;
  4004.   HWND     PopupHwnd;
  4005.   PUCMDATA UCMData    = (PUCMDATA)WinQueryWindowULong(hwndUCMenu, QWL_UCMDATA);
  4006.  
  4007.  
  4008.   // --------------------------------------
  4009.   // -- First check if context menu allowed
  4010.   // --------------------------------------
  4011.   if ( UCMData->Style & UCS_NO_CM ) {
  4012.      return;
  4013.   } // endif
  4014.  
  4015.   // -------------------------------------------------------------
  4016.   // -- UCMData->hwndCMOrig will be used to send the MM_INSERTITEM
  4017.   // -- If we add an item in the menu, send it to hwndUCMenu
  4018.   // --  If we add an item in a submenu, send it to the submenu
  4019.   // -------------------------------------------------------------
  4020.   if (UCMData->hwndMenu==hwndMenu) {
  4021.      UCMData->hwndCMOrig = hwndUCMenu;
  4022.   } else {
  4023.      UCMData->hwndCMOrig = hwndMenu;
  4024.   } // endif
  4025.  
  4026.   // ----------------------------------------------------------------
  4027.   // -- Query the id of the item under the mouse & get menu item info
  4028.   // ----------------------------------------------------------------
  4029.   if (FromMouse) {
  4030.      WinQueryPointerPos(HWND_DESKTOP, &ptl);
  4031.      WinMapWindowPoints(HWND_DESKTOP, hwndMenu, &ptl, 1);
  4032.      UCMData->ContextID = UCMenuIdFromCoord(hwndMenu, &ptl);
  4033.      WinMapWindowPoints(hwndMenu, HWND_DESKTOP, &ptl, 1);
  4034.   } else {
  4035.      RECTL Rectl;
  4036.      ULONG SelectedItem = (ULONG)
  4037.               WinSendMsg(hwndMenu, MM_QUERYSELITEMID, 0L, 0L);
  4038.      WinSendMsg( hwndMenu, MM_QUERYITEMRECT, (MPARAM)SelectedItem, MPFROMP(&Rectl));
  4039.      ptl.x = Rectl.xLeft   + (Rectl.xRight - Rectl.xLeft)/2;
  4040.      ptl.y = Rectl.yBottom + (Rectl.yTop - Rectl.yBottom)/2;
  4041.      UCMData->ContextID = UCMenuIdFromCoord(hwndMenu, &ptl);
  4042.      WinMapWindowPoints(hwndMenu, HWND_DESKTOP, &ptl, 1);
  4043.   }
  4044.  
  4045.   memset(&mi, 0x00, sizeof(MENUITEM));  // set to all zeros if not over an item
  4046.   if (UCMData->ContextID != 0)
  4047.     WinSendMsg( hwndMenu, MM_QUERYITEM, MPFROM2SHORT( UCMData->ContextID, FALSE ), MPFROMP( &mi ));
  4048.  
  4049.   /* See if the application has a context menu for us to use. */
  4050.   UCMData->hwndUserCM = (HWND)WinSendMsg(UCMData->hwndOwner, WM_CONTROL,
  4051.                               MPFROM2SHORT(UCMData->UCMenuID, UCN_QRYCONTEXTHWND),
  4052.                               MPFROMP(&mi));
  4053.  
  4054.   if (UCMData->hwndUserCM == NULLHANDLE) {  // Use our built-in menu
  4055.     #if !defined(UCMUI)
  4056.     return;           // No app context menu, and we don't support it
  4057.     #else
  4058.     PopupHwnd = UCMData->hwndCM;
  4059.     // ---------------------------------------------------------------------------
  4060.     // -- But if we were  on a MIS_SPACER item we won't be able to edit anyway
  4061.     // ---------------------------------------------------------------------------
  4062.     if ( mi.afStyle & MIS_SPACER ) {
  4063.       WinEnableMenuItem( UCMData->hwndCM, IDM_UCM_EDIT,   FALSE );
  4064.     } else {
  4065.       WinEnableMenuItem( UCMData->hwndCM, IDM_UCM_EDIT,   TRUE );
  4066.     } // endif
  4067.     // ---------------------------------------------------------------------------
  4068.     // -- But if we were not on an item we won't be able to edit and delete anyway
  4069.     // ---------------------------------------------------------------------------
  4070.     if ( UCMData->ContextID == 0 ) {
  4071.       WinEnableMenuItem( UCMData->hwndCM, IDM_UCM_DELETE, FALSE );
  4072.       WinEnableMenuItem( UCMData->hwndCM, IDM_UCM_EDIT,   FALSE );
  4073.     } else {
  4074.       WinEnableMenuItem( UCMData->hwndCM, IDM_UCM_DELETE, TRUE );
  4075.     } // endif
  4076.     #endif // UCMUI
  4077.   }
  4078.   else PopupHwnd = UCMData->hwndUserCM;    // Use application menu
  4079.  
  4080.   // Disable bubble help until popup is dismissed (WM_MENUEND message
  4081.   // processed in HideWndProc).  Otherwise bubble can overlay
  4082.   // and will be corrupted by poup repainting.
  4083.   WinSendMsg(UCMData->hwndBubble, MSG_DISABLE_BUBBLE, 0L, 0L);
  4084.  
  4085.   // --------------------------------------------------------------
  4086.   // -- At last pop up the  context menu.  Messages from this menu
  4087.   // -- will be processed by the HideWndProc() procedure.
  4088.   // --------------------------------------------------------------
  4089.   WinPopupMenu(HWND_DESKTOP,
  4090.                WinQueryWindow(UCMData->hwndMenu, QW_PARENT), // Hide window is owner
  4091.                PopupHwnd,
  4092.                ptl.x,
  4093.                ptl.y,
  4094.                0,
  4095.                PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 | PU_KEYBOARD |
  4096.                PU_HCONSTRAIN | PU_VCONSTRAIN);
  4097. } // endif
  4098.  
  4099. // (MAM) Added following routine
  4100. //----------------------------------------------------------------------------
  4101. // UCAdjacentItemBlank : Not for users doc
  4102. //----------------------------------------------------------------------------
  4103. // This function will take a menu item and see if the adjacent (left/right)
  4104. // item has the MIS_SPACER attribute, or if the given item is at the start/end
  4105. // of the menu.  A TRUE/FALSE is returned (TRUE if the adjacent item is
  4106. // a spacer or there is no adjacent item).  Last parm (LeftRight) is -1 for
  4107. // left/above check, +1 for right/below check.  The given ID is assumed to
  4108. // exist in the given menu.
  4109. //----------------------------------------------------------------------------
  4110.  
  4111. BOOL _Optlink UCAdjacentItemBlank(HWND MenuHwnd, SHORT ItemID, int LeftRight)
  4112. {
  4113.   SHORT ItemPos;      /* Position of this item in the menu */
  4114.   SHORT AdjItemID;    /* ID of adjacent menu item (if one) */
  4115.   MENUITEM MenuItem;  /* Adjacent item data                */
  4116.  
  4117.   ItemPos = (SHORT)WinSendMsg(MenuHwnd, MM_ITEMPOSITIONFROMID, MPFROM2SHORT(ItemID, FALSE), 0L);
  4118.   AdjItemID = (SHORT)WinSendMsg(MenuHwnd, MM_ITEMIDFROMPOSITION, MPFROMSHORT(ItemPos+LeftRight), 0L);
  4119.   if (AdjItemID != MIT_ERROR) {
  4120.     /* Get info about adjacent menu item and examine style flags */
  4121.     WinSendMsg(MenuHwnd, MM_QUERYITEM, MPFROM2SHORT(AdjItemID, FALSE), MPFROMP(&MenuItem));
  4122.     if (!(MIS_SPACER & MenuItem.afStyle))
  4123.       return FALSE;   /* There is a non-blank adjacent item */
  4124.   }
  4125.   return TRUE;        /* No adjacent item, or adjacent item is MIS_SPACER */
  4126. }
  4127.  
  4128. //----------------------------------------------------------------------------
  4129. // UCMenuWndProc
  4130. //----------------------------------------------------------------------------
  4131. // :pfunction res=&IDF_UCMWNDPROC. name='UCMenuWndProc' text='UCMenu window procedure'.
  4132. // Window procedure of the UCMenu class
  4133. // :syntax name='UCMenuWndProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  4134. // :fparams.
  4135. // :fparam name='hwnd' type='HWND' io='input' .
  4136. // UCMenu window handle
  4137. // :fparam name='msg' type='ULONG' io='input' .
  4138. // Message
  4139. // :fparam name='mp1' type='MPARAM' io='input'.
  4140. // First parameter
  4141. // :fparam name='mp2' type='MPARAM' io='input'.
  4142. // Second parameter
  4143. // :freturns.
  4144. // :fparam name='mresult' type='MRESULT' io='return'.
  4145. // Return code of a PM message.
  4146. // :efparams.
  4147. // :remarks.
  4148. // :dl compact.
  4149. // :dt.:hp2.WM_INITMENU:ehp2.
  4150. // :dd.:hp2.A submenu is about to be shown : we subclass it :ehp2.
  4151. // :dt.:hp2.WM_MENUEND:ehp2.
  4152. // :dd.:hp2.A submenu is about to be destroyed : we un-subclass it :ehp2.
  4153. // :dt.:hp2.WM_VSCROLL:ehp2.
  4154. // :dd.:hp2.Vertical scrolling event :ehp2.
  4155. // :dt.:hp2.WM_HSCROLL:ehp2.
  4156. // :dd.:hp2.Horizontal scrolling event :ehp2.
  4157. // :dt.:hp2.WM_DRAWITEM:ehp2.
  4158. // :dd.:hp2.Draws any OWNERDRAW menu item :ehp2.
  4159. // :dt.:hp2.WM_MEASUREITEM:ehp2.
  4160. // :dd.:hp2.Returns the height of an OWNERDRAW item :ehp2.
  4161. // :edl.
  4162. // :epfunction.
  4163. //----------------------------------------------------------------------------
  4164. MRESULT EXPENTRY UCMenuWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  4165. {
  4166.   ULONG Style      = WinQueryWindowULong(hwnd, QWL_STYLE);
  4167.   PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwnd, QWL_UCMDATA );
  4168.  
  4169.   switch (msg) {
  4170.      case WM_TRANSLATEACCEL:
  4171.           {
  4172.            //??? does this code work?
  4173.            //PACCELTABLE AccelTable;
  4174.              HWND        hwndMenu = UCMData->hwndMenu;
  4175.              PQMSG       QMsg = (PQMSG)mp1;
  4176.            //USHORT      VK  = SHORT2FROMMP(mp2);
  4177.  
  4178.              if(QMsg->msg == WM_CHAR) {
  4179.                 USHORT flags = SHORT1FROMMP(QMsg->mp1);
  4180.                 if(((flags & KC_CHAR)||!(flags & KC_VIRTUALKEY)) && (flags & KC_ALT) && !(flags & KC_PREVDOWN)) {
  4181.                    return (MRESULT) TranslateAccel(UCMData, hwndMenu, SHORT1FROMMP(QMsg->mp2), QMsg);
  4182.                 }
  4183.              }
  4184.              return (MRESULT)0;
  4185.           }
  4186.      case WM_UPDATEFRAME:
  4187.           {
  4188.              if ( ( (ULONG)mp1 == FCF_MENU ) && UCMData->bProcessingPP ){
  4189.                 // sent by the menu original wndproc after the processing of WM_PRESPARAMCHANGED
  4190.                 UCMenuUpdateMenu( UCMData->hwndMenu, FALSE );
  4191.                 UCMData->bProcessingPP = FALSE;
  4192.                 return (MRESULT) TRUE;
  4193.              } else {
  4194.                 return (MRESULT) FALSE;
  4195.              }
  4196.           }
  4197.      case UCMENU_ADDITEMSTOCM:
  4198.           {
  4199.             ULONG    i;
  4200.             MENUITEM MenuItem;
  4201.             ULONG    NbOfAdditionalCMItems = (ULONG)mp1;
  4202.             PCMITEMS CMItems = (PCMITEMS)mp2;
  4203.             memset(&MenuItem, 0, sizeof(MENUITEM));
  4204.             for(i=0; i<NbOfAdditionalCMItems; i++) {
  4205.                MenuItem.iPosition = MIT_END;
  4206.                MenuItem.id = (CMItems+i)->ID;
  4207.                MenuItem.afStyle = MIS_TEXT;
  4208.                WinSendMsg(UCMData->hwndCM, MM_INSERTITEM, MPFROMP(&MenuItem),
  4209.                           MPFROMP( (CMItems+i)->pszItemText ) );
  4210.             }
  4211.             return((MRESULT)0);
  4212.           }
  4213.  
  4214.      case UCMENU_DELETECMITEM:
  4215.           {
  4216.             ULONG    i;
  4217.             ULONG    NbOfItems = (ULONG)mp1;
  4218.             PULONG   ItemArray = (PULONG)mp2;
  4219.             for(i=0; i<NbOfItems; i++) {
  4220.                WinSendMsg(UCMData->hwndCM, MM_DELETEITEM, (MPARAM)ItemArray[i], 0L);
  4221.             }
  4222.             return (MRESULT)0;
  4223.           }
  4224.     case WM_PRESPARAMCHANGED:
  4225.           {
  4226.              UCMenuPresParamChanged(UCMData, hwnd, mp1 );
  4227.              return((MRESULT)0);
  4228.           }
  4229.      case UCMENU_QUERYSIZE:
  4230.          {
  4231.             if ( UCMData && mp1 && mp2 ){
  4232.                if (Style & CMS_MATRIX) {
  4233.                   //(MAM) changed to return real size based on actual number of
  4234.                   // rows and columns in use.
  4235.                   USHORT Count, Rows;
  4236.                   Count = (USHORT)WinSendMsg(hwnd, MM_QUERYITEMCOUNT, MPVOID, MPVOID);
  4237.                   * (ULONG*)mp1 = min(Count,UCMData->NbOfCols) * UCMData->MaxVerticalWidth    + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4238.                   Rows = Count / max(1,UCMData->NbOfCols);  // Full rows (don't div by zero!)
  4239.                   if ((Rows * UCMData->NbOfCols) < Count)   // Partial row?
  4240.                     Rows++;
  4241.                   * (ULONG*)mp2 = Rows * UCMData->MaxHorizontalHeight + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4242.                } // endif
  4243.                if ( Style & CMS_VERT ) {
  4244.                   * (ULONG*)mp1 = UCMData->MaxVerticalWidth + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4245.                   * (ULONG*)mp2 = UCMData->SumItemHeights   + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4246.                } // endif
  4247.                if ( Style & CMS_HORZ ) {
  4248.                   * (ULONG*)mp1 = UCMData->SumItemWidths       + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4249.                   * (ULONG*)mp2 = UCMData->MaxHorizontalHeight + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  4250.                } // endif
  4251.                return (MRESULT)TRUE;
  4252.             } else {
  4253.                return (MRESULT)FALSE;
  4254.             } // endif
  4255.          }
  4256.  
  4257.     case UCMENU_QUERYCOLOR:
  4258.        {
  4259.           if ( UCMData && mp1 && mp2 ) {
  4260.              * (LONG*)mp1 = UCMData->BgColor;
  4261.              * (LONG*)mp2 = UCMData->ItemBgColor;
  4262.              return (MRESULT)TRUE;
  4263.           } else {
  4264.              return (MRESULT)FALSE;
  4265.           } // endif
  4266.        }
  4267.  
  4268.     case UCMENU_QUERYSTYLE:
  4269.        {
  4270.           if ( UCMData && mp1) {
  4271.              * (ULONG*)mp1 = UCMData->Style;
  4272.              return (MRESULT) TRUE;
  4273.           } else {
  4274.              return (MRESULT) FALSE;
  4275.           } // endif
  4276.       }
  4277.  
  4278.     case UCMENU_SETSTYLE:
  4279.        {
  4280.           if ( UCMData ) {
  4281.              /* If removing bubble-help, destroy bubble window */
  4282.              if ((UCMData->hwndBubble != NULLHANDLE) && !((ULONG)mp1 & UCS_BUBBLEHELP)) {
  4283.                WinDestroyWindow(UCMData->hwndBubble);
  4284.                UCMData->hwndBubble = NULLHANDLE;
  4285.             // UCMData->HoverCapture = FALSE;
  4286.                UCMData->HoverID = 0;
  4287.              }
  4288.  
  4289.              /* If adding bubble-help, create bubble window */
  4290.              if ((UCMData->hwndBubble == NULLHANDLE) && ((ULONG)mp1 & UCS_BUBBLEHELP))
  4291.                UCMenuCreateBubbleWindow(hwnd, UCMData);
  4292.  
  4293.              UCMData->Style = (ULONG)mp1;
  4294.              UCMData->cx    = SHORT1FROMMP(mp2);
  4295.              UCMData->cy    = SHORT2FROMMP(mp2);
  4296.              return (MRESULT) TRUE;
  4297.           } else {
  4298.              return (MRESULT) FALSE;
  4299.           } // endif
  4300.       }
  4301.  
  4302.     case UCMENU_SETBGCOLOR:
  4303.        {
  4304.           if ( UCMData ) {
  4305.              UCMData->BgColor      = (ULONG)mp1;
  4306.              UCMData->ItemBgColor  = (ULONG)mp2;
  4307.              WinSetPresParam( UCMData->hwndMenu,
  4308.                               PP_MENUBACKGROUNDCOLOR,
  4309.                               sizeof UCMData->ItemBgColor,
  4310.                               &(UCMData->ItemBgColor) );
  4311.              return (MRESULT) TRUE;
  4312.           } else {
  4313.              return (MRESULT) FALSE;
  4314.           } // endif
  4315.       }
  4316.     case UCMENU_SETFONT :
  4317.       {
  4318.          if ( mp1 && UCMData ){
  4319.             if ( WinSetPresParam( UCMData->hwndMenu, PP_FONTNAMESIZE, strlen( mp1 ) + 1, mp1 ) ){
  4320.                if ( UCMData->pszFontNameSize ) {
  4321.                   MyFree( UCMData->pszFontNameSize );
  4322.                } /* endif */
  4323.                UCMData->pszFontNameSize = MyMalloc( strlen( mp1 ) + 1 );
  4324.                if ( UCMData->pszFontNameSize ){
  4325.                   strcpy( UCMData->pszFontNameSize, mp1 );
  4326.                } /* endif */
  4327.                return (MRESULT)TRUE;
  4328.             } else {
  4329.                return (MRESULT)FALSE;
  4330.             } /* endif */
  4331.          } else {
  4332.             return (MRESULT)FALSE;
  4333.          } /* endif */
  4334.       }
  4335.  
  4336.     case UCMENU_SETBUBBLETIMERS: // Added V2.04
  4337.        {
  4338.           UCMData->BubbleDelay = LONGFROMMP(mp1);
  4339.           UCMData->BubbleRead  = LONGFROMMP(mp2);
  4340.           return 0;
  4341.        }
  4342.  
  4343.     case UCMENU_ACTIVECHG:  // Added V2.04
  4344.        {
  4345.           if (!(BOOL)SHORT1FROMMP(mp1)) {  // Becoming inactive
  4346.             /* When owning app becomes inactive we will close any open */
  4347.             /* submenu and deactivate the bubble help, if any.         */
  4348.             UCMData->Active = FALSE;
  4349.             if (UCMData->usItem != 0) {   // There is an open submenu, close it
  4350.                MENUITEM OpenItem;
  4351.                if ((BOOL)WinSendMsg(UCMData->hwndMenu,
  4352.                           MM_QUERYITEM,
  4353.                           MPFROM2SHORT(UCMData->usItem,TRUE),
  4354.                           MPFROMP(&OpenItem)))
  4355.                  WinSendMsg(OpenItem.hwndSubMenu, MM_ENDMENUMODE, MPFROMSHORT(TRUE), 0L);
  4356.             }
  4357.             if (UCMData->Style & UCS_BUBBLEHELP) {
  4358.           //  if (UCMData->HoverCapture)
  4359.           //    WinSetCapture(HWND_DESKTOP, NULLHANDLE);
  4360.           //  UCMData->HoverCapture = FALSE;
  4361.               UCMData->HoverID = 0;
  4362.               WinSendMsg(UCMData->hwndBubble,  // Deactivate bubble if showing
  4363.                           MSG_ITEMCHANGE, MPFROM2SHORT(0, TRUE), MPFROMHWND(hwnd));
  4364.             }
  4365.           }
  4366.           else {  // Becoming active
  4367.             /* When owning app becomes active, we fake a mouse message if the */
  4368.             /* pointer is over toolbar window to reactivate the bubble help.  */
  4369.             UCMData->Active = TRUE;
  4370.             if (UCMData->Style & UCS_BUBBLEHELP) {
  4371.               POINTL MousePos;
  4372.               WinQueryPointerPos((HAB)NULLHANDLE, &MousePos);
  4373.               WinMapWindowPoints(HWND_DESKTOP,UCMData->hwndMenu,&MousePos, 1);
  4374.               WinSendMsg(UCMData->hwndMenu, WM_MOUSEMOVE, MPFROM2SHORT((SHORT)MousePos.x,(SHORT)MousePos.y), MPFROM2SHORT(0,KC_NONE));
  4375.             }
  4376.           }
  4377.        } // end UCMENU_ACTIVECHG
  4378.        return 0;
  4379.  
  4380.     case UCMENU_UPDATE:
  4381.        {
  4382.           if ( UCMData ) {
  4383.              UCMenuUpdateMenu( UCMData->hwndMenu, TRUE );
  4384.              return (MRESULT) TRUE;
  4385.           } else {
  4386.              return (MRESULT) FALSE;
  4387.           } // endif
  4388.       }
  4389.  
  4390.     case UCMENU_DISABLEUPDATE:
  4391.       /* Set update disable status */
  4392.       UCMData->DisableUpdate = (BOOL)SHORT1FROMMP(mp1);
  4393.       return 0;
  4394.  
  4395.     case UCMENU_QUERYFORCEDSIZE:
  4396.        {
  4397.           if ( UCMData && mp1 && mp2 ) {
  4398.              * (ULONG*)mp1 = UCMData->cx;
  4399.              * (ULONG*)mp2 = UCMData->cy;
  4400.              return (MRESULT)TRUE;
  4401.           } else {
  4402.              return (MRESULT)FALSE;
  4403.           } // endif
  4404.       }
  4405.  
  4406.     case UCMENU_QUERYFONT:
  4407.        {
  4408.           if ( UCMData && UCMData->pszFontNameSize && mp1 ) {
  4409.              if ( (ULONG)mp2 > strlen( UCMData->pszFontNameSize) ) {
  4410.                 strcpy( (CHAR *)mp1, UCMData->pszFontNameSize );
  4411.                 return (MRESULT)TRUE;
  4412.              } else {
  4413.                 return (MRESULT)FALSE;
  4414.              } // endif
  4415.           } else {
  4416.              return (MRESULT)FALSE;
  4417.           } // endif
  4418.        }
  4419.  
  4420.     case UCMENU_QUERYRECT:
  4421.        /* Return the bounding rectangle of the specified menu item, */
  4422.        /* relative to the UCMenu toolbar window.  mp1(short1) is    */
  4423.        /* the item ID, mp2 is ptr to RECTL.  Return TRUE if OK.     */
  4424.  
  4425.        /* See if item is on main menu */
  4426.        if ((BOOL) WinSendMsg(UCMData->hwndMenu, MM_QUERYITEMRECT, MPFROM2SHORT(SHORT1FROMMP(mp1), FALSE), MPFROMP((PRECTL)PVOIDFROMMP(mp2)))) {
  4427.          WinMapWindowPoints(UCMData->hwndMenu, hwnd, (POINTL *)PVOIDFROMMP(mp2), 2);
  4428.          return (MRESULT)TRUE;
  4429.        }
  4430.        /* If a submenu is currently open, try there */
  4431.        else if (UCMData->usItem != 0) {
  4432.          MENUITEM Item;
  4433.          if ((BOOL) WinSendMsg(hwnd, MM_QUERYITEM, MPFROM2SHORT(UCMData->usItem, TRUE), MPFROMP(&Item))) {
  4434.             if ((BOOL) WinSendMsg(Item.hwndSubMenu, MM_QUERYITEMRECT, MPFROM2SHORT(SHORT1FROMMP(mp1), FALSE), MPFROMP((PRECTL)PVOIDFROMMP(mp2)))) {
  4435.                WinMapWindowPoints(Item.hwndSubMenu, hwnd, (POINTL *)PVOIDFROMMP(mp2), 2);
  4436.                return (MRESULT)TRUE;
  4437.             }
  4438.          }
  4439.        }
  4440.        return (MRESULT)FALSE; // Not found.
  4441.  
  4442.     case UCMENU_QUERYUCMINFO:
  4443.        {
  4444.           if ( UCMData && mp1 ){
  4445.              PUCMINFO UCMInfo  = (PUCMINFO)mp1;
  4446.  
  4447.              UCMInfo->cb           = sizeof(UCMINFO);
  4448.              UCMInfo->hModule      = UCMData->hModBmp;
  4449.              UCMInfo->NbOfCols     = UCMData->NbOfCols;
  4450.              UCMInfo->NbOfRows     = UCMData->NbOfRows;
  4451.              UCMInfo->Style        = UCMData->Style;
  4452.              UCMInfo->cx           = UCMData->cx;
  4453.              UCMInfo->cy           = UCMData->cy;
  4454.              UCMInfo->BgBmp        = UCMData->BgBmp;
  4455.              UCMInfo->BgColor      = UCMData->BgColor;
  4456.              UCMInfo->ItemBgColor  = UCMData->ItemBgColor;
  4457.              UCMInfo->hModUCM      = UCMData->hModUCM;        // added V2.04
  4458.              UCMInfo->BubbleDelay  = UCMData->BubbleDelay;    // added V2.04 
  4459.              UCMInfo->BubbleRead   = UCMData->BubbleRead;     // added V2.04
  4460.  
  4461.              if ( *(UCMData->szBitmapSearchPath) &&
  4462.                   (UCMInfo->pszBitmapSearchPath = MyMalloc(strlen( UCMData->szBitmapSearchPath )+1)) ){
  4463.                 strcpy( UCMInfo->pszBitmapSearchPath, UCMData->szBitmapSearchPath );
  4464.              } else {
  4465.                 UCMInfo->pszBitmapSearchPath = NULL;
  4466.              } // endif
  4467.  
  4468.              if ( *(UCMData->szDefaultBitmap) &&
  4469.                   (UCMInfo->pszDefaultBitmap = MyMalloc(strlen( UCMData->szDefaultBitmap )+1)) ){
  4470.                 strcpy( UCMInfo->pszDefaultBitmap, UCMData->szDefaultBitmap );
  4471.              } else {
  4472.                 UCMInfo->pszDefaultBitmap = NULL;
  4473.              } // endif
  4474.  
  4475.              if ( UCMData->pszFontNameSize &&
  4476.                   (UCMInfo->pszFontNameSize = MyMalloc(strlen( UCMData->pszFontNameSize )+1)) ){
  4477.                 strcpy( UCMInfo->pszFontNameSize, UCMData->pszFontNameSize );
  4478.              } else {
  4479.                 UCMInfo->pszFontNameSize = NULL;
  4480.              } // endif
  4481.  
  4482.              return (MRESULT)TRUE;
  4483.           } else {
  4484.              return (MRESULT)FALSE;
  4485.           } // endif
  4486.        }
  4487.  
  4488.     case UCMENU_QUERYVERSION:
  4489.        {
  4490.           return (MRESULT)(ULONG)UCMENUS_VERSION;  // constant defined in ucmenus.h
  4491.        }
  4492.  
  4493.     case UCMENU_ACTIONSINSERTED:
  4494.       //-- This message is posted by the owner to let me know that
  4495.       //-- the list of actions was filled. What I have to do is hilite the
  4496.       //-- current action in the list or, if it's not in it, add it to the
  4497.       //-- list and highlight it.
  4498.       #if !defined(UCMUI)
  4499.         return 0;
  4500.       #else
  4501.         if (UCMData->hwndPage2)
  4502.           WinPostMsg(UCMData->hwndPage2,
  4503.                      UCMENU_ACTIONSINSERTED,
  4504.                      (MPARAM)0,
  4505.                      (MPARAM)0);
  4506.         return 0;
  4507.       #endif
  4508.  
  4509.     case UCMENU_INSERTACTION:
  4510.       #if !defined(UCMUI)
  4511.         return 0;
  4512.       #else
  4513.         WinSendDlgItemMsg(UCMData->hwndPage2,
  4514.                           IDC_UCMNBP2FLIST,
  4515.                           LM_INSERTITEM,
  4516.                           (MPARAM)LIT_END,
  4517.                           mp1);
  4518.         WinSendDlgItemMsg(UCMData->hwndPage2,
  4519.                           IDC_UCMNBP2DLIST,
  4520.                           LM_INSERTITEM,
  4521.                           (MPARAM)LIT_END,
  4522.                           mp2);
  4523.         return (MRESULT)0;
  4524.       #endif
  4525.  
  4526.     case WM_CONTEXTMENU:
  4527.       {
  4528.  
  4529.        UCMenuContextMenu(hwnd, UCMData->hwndMenu, (ULONG)mp1);
  4530.        return (MRESULT) TRUE;
  4531.       }
  4532.  
  4533.     case WM_CREATE:
  4534.       /*---------------------------------------------*/
  4535.       /*        Create code                          */
  4536.       /*---------------------------------------------*/
  4537.      { PCREATESTRUCT CreateParms = (PCREATESTRUCT)mp2;
  4538.        PUCMINFO2      UCMInfo     = (PUCMINFO2)mp1;
  4539.        RECTL         rcl;
  4540.        HPS           hps;
  4541.        HDC           hdcMem;
  4542.  
  4543.  
  4544.        // Test if the menu handle is valid
  4545.        if ( !WinIsWindow( WinQueryAnchorBlock( hwnd ), UCMInfo->hwndMenu ) ) {
  4546.           return (MRESULT)FALSE;
  4547.        } // endif
  4548.  
  4549.        // Allocate memory for UCMenu internal Data
  4550.        if(!(UCMData = MyMalloc(sizeof(UCMDATA)))) {
  4551.           return((MRESULT)1);
  4552.        }
  4553.  
  4554.        // Zero out memory
  4555.        memset(UCMData, 0, sizeof(UCMDATA));
  4556.  
  4557.        UCMData->size = sizeof( UCMDATA );
  4558.  
  4559.        WinSetWindowULong(hwnd, QWL_UCMDATA, (ULONG)UCMData);
  4560.  
  4561.        /* These are new in UCMDATA for V2.04 */
  4562.        UCMData->hwndUCM = hwnd;
  4563.        UCMData->hwndOwner = WinQueryWindow(hwnd, QW_OWNER);
  4564.        UCMData->UCMenuID = WinQueryWindowUShort(hwnd, QWS_ID);
  4565.  
  4566.        // -----------------------------------------------------------------------
  4567.        // -- Eventually create a memory device context to manipulate the bitmaps
  4568.        // -- We need that if we want to change their background color
  4569.        // -----------------------------------------------------------------------
  4570.        if (UCMInfo->Style & (UCS_CHNGBMPBG|UCS_CHNGBMPBG_AUTO))   {
  4571.          hdcMem = DevOpenDC( WinQueryAnchorBlock( hwnd ),
  4572.                              OD_MEMORY,
  4573.                              "*",
  4574.                              0L,
  4575.                              NULL,       // -- compatible with screen device
  4576.                              (ULONG)0 );
  4577.          if ( hdcMem ) {
  4578.             SIZEL sizlPS;
  4579.  
  4580.             sizlPS.cx = 0;
  4581.             sizlPS.cy = 0;
  4582.             UCMData->hpsMem = GpiCreatePS( WinQueryAnchorBlock( hwnd ),
  4583.                                            hdcMem,
  4584.                                            &sizlPS,
  4585.                                            PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC );
  4586.  
  4587.          } // endif
  4588.        } // endif
  4589.  
  4590.        // Allocate memory for the accelerator table
  4591.        UCMData->AccelTable = (PACCELTABLE)MyMalloc(sizeof(ACCELTABLE)+(100*sizeof(ACCEL)));
  4592.        UCMData->AccelTable->codepage = 850;
  4593.        UCMData->AccelTable->cAccel   = 0;
  4594.  
  4595.        rcl.xLeft   = CreateParms->x;
  4596.        rcl.xRight  = CreateParms->x + CreateParms->cx;
  4597.        rcl.yTop    = CreateParms->y + CreateParms->cy;
  4598.        rcl.yBottom = CreateParms->y;
  4599.  
  4600.        if(UCMInfo->pszBitmapSearchPath) {
  4601.           strcpy(UCMData->szBitmapSearchPath, UCMInfo->pszBitmapSearchPath);
  4602.        }
  4603.  
  4604.        if(UCMInfo->pszDefaultBitmap) {
  4605.           strcpy(UCMData->szDefaultBitmap, UCMInfo->pszDefaultBitmap);
  4606.        }
  4607.  
  4608.        UCMData->NbOfRows = UCMInfo->NbOfRows;
  4609.        UCMData->NbOfCols = UCMInfo->NbOfCols;
  4610.        UCMData->Style    = UCMInfo->Style;
  4611.        UCMData->cx       = UCMInfo->cx;
  4612.        UCMData->cy       = UCMInfo->cy;
  4613.        // -----------------------------------------------------------------------
  4614.        // -- We want only solid colors, because the bitmap background can only be
  4615.        // -- solid, and we want it to match with everything we paint
  4616.        // -----------------------------------------------------------------------
  4617.        hps = WinGetPS( UCMInfo->hwndMenu );
  4618.        UCMData->BgBmp = UCMInfo->BgBmp;  // Background color in real bitmap can be anything
  4619.      //UCMData->BgBmp        = GpiQueryNearestColor( hps, (ULONG)0, UCMInfo->BgBmp );
  4620.        UCMData->BgColor      = GpiQueryNearestColor( hps, (ULONG)0, UCMInfo->BgColor );
  4621.        UCMData->ItemBgColor  = GpiQueryNearestColor( hps, (ULONG)0, UCMInfo->ItemBgColor );
  4622.        WinReleasePS( hps );
  4623.  
  4624.        UCMData->hwndMenu = UCMInfo->hwndMenu;
  4625.  
  4626.        // -----------------------------------------------------------------------
  4627.        // -- The WinSetPresParam causes a WM_UPDATEFRAME to be sent to the owner,
  4628.        // -- this will cause trouble if the owner is a WC_FRAME or if it is already
  4629.        // -- the ucmenu, -> set the owner temporarily to the desktop object window
  4630.        // -----------------------------------------------------------------------
  4631.        WinSetOwner (UCMInfo->hwndMenu, HWND_OBJECT);
  4632.  
  4633.        // -------------------------------------------------------------------------------------------
  4634.        // -- The presparam change has to be done before subclassing the menu, else it fails
  4635.        // -- (Here, we want to have PRESPARAMCHANGED processed by the default routines only,
  4636.        // -- since everything is not set up yet, especially the UCMData * in QWL_USER or QWL_UCMDATA)
  4637.        // -------------------------------------------------------------------------------------------
  4638.        if ( ! UCMInfo->pszFontNameSize ){
  4639.           UCMInfo->pszFontNameSize = MyMalloc( strlen( UCM_DEFAULTFONT ) + 1 );
  4640.           strcpy( UCMInfo->pszFontNameSize, UCM_DEFAULTFONT );
  4641.        }
  4642.        WinSetPresParam( UCMInfo->hwndMenu, PP_FONTNAMESIZE,
  4643.                         strlen(UCMInfo->pszFontNameSize) + 1,
  4644.                         UCMInfo->pszFontNameSize);
  4645.  
  4646.  
  4647.        if ( UCMData->pszFontNameSize = MyMalloc( strlen( UCMInfo->pszFontNameSize ) + 1 ) ){
  4648.           strcpy( UCMData->pszFontNameSize, UCMInfo->pszFontNameSize );
  4649.        }
  4650.  
  4651.        WinSetPresParam( UCMInfo->hwndMenu, PP_MENUBACKGROUNDCOLOR, sizeof UCMData->ItemBgColor, &(UCMData->ItemBgColor) );
  4652.  
  4653.        WinSetOwner (UCMInfo->hwndMenu, hwnd);
  4654.  
  4655.        UCMData->OldMenuProc = (PFNWP)WinSubclassWindow(UCMInfo->hwndMenu, (PFNWP)MenuWndProc);
  4656.  
  4657.        /* As of UCMenus V2.04, app must supply our module handle if we are  */
  4658.        /* in a DLL.  Otherwise we do our best to get it ourselves, but may  */
  4659.        /* not work if we are in a DLL loaded by full path name.             */
  4660.  
  4661.        UCMData->hModUCM = UCMInfo->hModUCM;
  4662.        if (UCMData->hModUCM == NULLHANDLE) {
  4663.          //--- Here we have to get the module name to load the resource
  4664.          PSZ pszModuleName = "UCMENUS";
  4665.          // ----------------------------------------------------------------
  4666.          // -- If we can not find ucmenus.dll then we use 0, this will work
  4667.          // -- if we are statically linked to an exe
  4668.          // ----------------------------------------------------------------
  4669.          if ( DosQueryModuleHandle(pszModuleName, &(UCMData->hModUCM)) ){
  4670.                UCMData->hModUCM = NULLHANDLE;
  4671.          } // endif
  4672.        } // endif
  4673.  
  4674.        UCMData->hModBmp = UCMInfo->hModule; // Application resources from this module
  4675.        UCMData->BubbleDelay = UCMInfo->BubbleDelay;
  4676.        UCMData->BubbleRead  = UCMInfo->BubbleRead;
  4677.  
  4678.        CreateUCMenu(hwnd,
  4679.                     CreateParms->hwndParent,
  4680.                     CreateParms->hwndOwner,
  4681.                     UCMInfo->hwndMenu,
  4682.                     CreateParms->id,
  4683.                     &rcl,
  4684.                     CreateParms->flStyle,
  4685.                     UCMInfo->NbOfCols,
  4686.                     UCMInfo->NbOfRows,
  4687.                     UCMInfo->ulTmplVersion);
  4688.  
  4689.  
  4690.        //-- Load the context menu
  4691.        UCMData->hwndCM = WinLoadMenu(HWND_OBJECT,   // was hwnd
  4692.                               UCMData->hModUCM,
  4693.                               IDD_UCMCTXT);
  4694.       WinGetLastError( WinQueryAnchorBlock( hwnd ) );
  4695.  
  4696.   // ------------------------------------------------------------
  4697.   // -- Set the context menu items according to the UCS_ flags
  4698.   // ------------------------------------------------------------
  4699.   if ( UCMData->Style & UCS_NO_CM_SEPARATOR ){
  4700.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_SEPARATOR, TRUE ), (MPARAM)0 );
  4701.   } // endif
  4702.   if ( UCMData->Style & UCS_NO_CM_ITEM_CREATE ){
  4703.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_CREATE, TRUE ), (MPARAM)0 );
  4704.   } // endif
  4705.   if ( UCMData->Style & UCS_NO_CM_ITEM_DELETE ){
  4706.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_DELETE, TRUE ), (MPARAM)0 );
  4707.   } // endif
  4708.   if ( UCMData->Style & UCS_NO_CM_ITEM_EDIT ){
  4709.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_EDIT, TRUE ), (MPARAM)0 );
  4710.   } // endif
  4711.   if ( UCMData->Style & UCS_NO_CM_MENU_STYLE ){
  4712.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_STYLE, TRUE ), (MPARAM)0 );
  4713.   } // endif
  4714.   if ( UCMData->Style & UCS_NO_CM_MENU_DEFAULT ){
  4715.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_DEFAULT, TRUE ), (MPARAM)0 );
  4716.   } // endif
  4717.   if ( UCMData->Style & UCS_NO_CM_MENU_IMPORT ){
  4718.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_LOAD, TRUE ), (MPARAM)0 );
  4719.   } // endif
  4720.   if ( UCMData->Style & UCS_NO_CM_MENU_EXPORT ){
  4721.      WinSendMsg( UCMData->hwndCM, MM_DELETEITEM, MPFROM2SHORT( IDM_UCM_SAVEAS, TRUE ), (MPARAM)0 );
  4722.   } // endif
  4723.  
  4724.   /* Create bubble help window if required by style */
  4725.  
  4726.   if (UCMData->Style & UCS_BUBBLEHELP)
  4727.     UCMenuCreateBubbleWindow(hwnd, UCMData);
  4728.  
  4729.   /* Try to determine if our app is currently the active window so */
  4730.   /* we can set our initial Active state correctly.  If the        */
  4731.   /* parent of the UCMenu is a child of the active window then     */
  4732.   /* our app is active.                                            */
  4733.  
  4734.   if (WinIsChild(WinQueryWindow(hwnd, QW_PARENT), WinQueryActiveWindow(HWND_DESKTOP)))
  4735.     UCMData->Active = TRUE;
  4736.  
  4737.   } break;  // end of WM_CREATE
  4738.  
  4739.     /*┌───────────────┐
  4740.       │ Menu messages │
  4741.       └───────────────┘*/
  4742.     case WM_INITMENU:
  4743.       {
  4744.          /*┌──────────────────────────────────────────────────────────────────┐
  4745.            │ A submenu is about to be shown : we save the item Identifier of  │
  4746.            │ the currently open submenu.                                      │
  4747.            └──────────────────────────────────────────────────────────────────┘*/
  4748.  
  4749.          UCMData->usItem = (USHORT)mp1;
  4750.          WinPostMsg(UCMData->hwndOwner, msg, mp1, mp2);
  4751.       }
  4752.       break;
  4753.  
  4754.     case WM_MENUEND:
  4755.       {
  4756.          /*┌──────────────────────────────────────────────────────────────────┐
  4757.            │ A submenu is about to end : zero the submenu ID                  │
  4758.            └──────────────────────────────────────────────────────────────────┘*/
  4759.          mp2 = MPFROMHWND(hwnd);
  4760.          WinPostMsg(UCMData->hwndOwner, msg, mp1, mp2);
  4761.          UCMData->usItem = 0;
  4762.       }
  4763.       break;
  4764.  
  4765.     case WM_MEASUREITEM:
  4766.       /*┌────────────────────────────────────────────────────────────────────────┐
  4767.         │ We receive this message the first time an item with the OWNERDRAW      │
  4768.         │ style is about to be drawn. We have to set the item's height and width │
  4769.         │ In submenus, we have to decrease xRight by DELTA because of the space  │
  4770.         │ left by PM for the arrow and check item.  PM docs (2.1) indicate only  │
  4771.         │ the height is required, but we set both width and height in the item   │
  4772.         │ rectangle structure and return the height in the message result.       │
  4773.         └────────────────────────────────────────────────────────────────────────┘*/
  4774.       { POWNERITEM        pitem;
  4775.         BITMAPINFOHEADER2 BmpInfo;
  4776.         SHORT             delta=0;
  4777.         ULONG             cx, cy;
  4778.  
  4779.         pitem = (POWNERITEM)mp2;
  4780.         BmpInfo.cbFix = sizeof(BITMAPINFOHEADER2);
  4781.         UCMenuCalcItemSize( pitem, UCMData->Style, hwnd, &cx, &cy );
  4782.  
  4783.         if ( WinQueryWindow(pitem->hwnd, QW_OWNER) != hwnd ) {
  4784.           // -- This is a submenu item and not a menu item
  4785.           HBITMAP hbm;
  4786.  
  4787.           hbm = WinGetSysBitmap(HWND_DESKTOP, SBMP_MENUCHECK);
  4788.           GpiQueryBitmapInfoHeader(hbm, &BmpInfo);
  4789.           delta += BmpInfo.cx;
  4790.           GpiDeleteBitmap(hbm);
  4791.  
  4792.           hbm = WinGetSysBitmap(HWND_DESKTOP, SBMP_MENUATTACHED);
  4793.           GpiQueryBitmapInfoHeader(hbm, &BmpInfo);
  4794.           delta += BmpInfo.cx;
  4795.           GpiDeleteBitmap(hbm);
  4796.         } // endif
  4797.  
  4798.         // In the submenus, PM will add some space for the checkmark&arrow : - delta
  4799.         //  (We don't want unnecessary space around the non checkable items)
  4800.         pitem->rclItem.xLeft   = 0;
  4801.         pitem->rclItem.yBottom = 0;
  4802.         pitem->rclItem.xRight  = cx  - delta ;
  4803.         pitem->rclItem.yTop    = cy  ;
  4804.  
  4805.         return MRFROMSHORT((SHORT)cy); // Return height of menu item
  4806.       } 
  4807.  
  4808.     case WM_DRAWITEM:
  4809.       /*┌───────────────────────────────────────────────────────────┐
  4810.         │ We receive this message when we have to draw an item with │
  4811.         │ the OWNERDRAW style                                       │
  4812.         └───────────────────────────────────────────────────────────┘*/
  4813.        {
  4814.         POWNERITEM        poi;
  4815.         PSZ               pszText;
  4816.         POINTL            aptlPoints[4];
  4817.         ULONG             TextHeight, TextWidth;
  4818.         ULONG             ItemBgColorIndex;
  4819.         ULONG             BgColorIndex;
  4820.         ULONG flOptions;
  4821.         HPS hps;
  4822.  
  4823.         poi = (POWNERITEM)mp2;
  4824.  
  4825.         /* Presentation space given in owner-draw structure does not */
  4826.         /* render larger fonts correctly (not sure why).  So we get  */
  4827.         /* our own pres space instead to use for the drawing.        */
  4828.  
  4829.         hps = WinGetPS(poi->hwnd);       //@P1a
  4830.  
  4831.         ItemBgColorIndex = UCMenuSelectColor( UCMData->ItemBgColor, hps ); //@P1m
  4832.         BgColorIndex = UCMenuSelectColor( UCMData->BgColor, hps );         //@P1m
  4833.  
  4834.         if (poi->fsState & MIS_SPACER) {
  4835.            /*------------- Draw spacer items -----------------------*/
  4836.  
  4837.            WinFillRect(hps, &poi->rclItem, BgColorIndex);
  4838.            if ( UCMData->Style & UCS_FRAMED ){
  4839.               POINTL pt;
  4840.               if ( Style & CMS_HORZ ){
  4841.                  // (MAM) Don't draw edges adjacent to other MIS_SPACER items
  4842.                  if (!UCAdjacentItemBlank(hwnd, poi->idItem, ADJACENT_LEFT)) {
  4843.                    pt.x = poi->rclItem.xLeft;
  4844.                    pt.y = poi->rclItem.yBottom ;
  4845.                    GpiMove( hps, &pt );
  4846.                    pt.y  = poi->rclItem.yTop - 1;
  4847.                    GpiSetColor( hps, SYSCLR_BUTTONDARK );
  4848.                    GpiLine( hps, &pt );
  4849.                  }
  4850.                  if (!UCAdjacentItemBlank(hwnd, poi->idItem, ADJACENT_RIGHT)) {
  4851.                    pt.x = poi->rclItem.xRight - 1;
  4852.                    pt.y = poi->rclItem.yBottom;
  4853.                    GpiMove( hps, &pt );
  4854.                    pt.y  = poi->rclItem.yTop - 1;
  4855.                    GpiSetColor( hps, SYSCLR_BUTTONLIGHT );
  4856.                    GpiLine( hps, &pt );
  4857.                  }
  4858.               } else if ( Style & CMS_VERT ){
  4859.                  // (MAM) Don't draw edges adjacent to other MIS_SPACER items
  4860.                  if (!UCAdjacentItemBlank(hwnd, poi->idItem, ADJACENT_ABOVE)) {
  4861.                    pt.x = poi->rclItem.xLeft;
  4862.                    pt.y = poi->rclItem.yBottom ;
  4863.                    GpiMove( hps, &pt );
  4864.                    pt.x  = poi->rclItem.xRight - 1;
  4865.                    GpiSetColor( hps, SYSCLR_BUTTONLIGHT );
  4866.                    GpiLine( hps, &pt );
  4867.                  }
  4868.                  if (!UCAdjacentItemBlank(hwnd, poi->idItem, ADJACENT_BELOW)) {
  4869.                    pt.x = poi->rclItem.xLeft;
  4870.                    pt.y = poi->rclItem.yTop - 1 ;
  4871.                    GpiMove( hps, &pt );
  4872.                    pt.x  = poi->rclItem.xRight - 1;
  4873.                    GpiSetColor( hps, SYSCLR_BUTTONDARK );
  4874.                    GpiLine( hps, &pt );
  4875.                  }
  4876.               } else if (Style & CMS_MATRIX ){
  4877.                  UCMenu3DFrame( hps, &poi->rclItem, 1);
  4878.               } // endif
  4879.            } // endif
  4880.            if (poi->fsAttribute != poi->fsAttributeOld) {
  4881.               poi->fsAttributeOld = (poi->fsAttribute &= (USHORT)~MIA_HILITED);
  4882.            } // endif
  4883.            WinReleasePS(hps);
  4884.            return (MRESULT)TRUE;
  4885.         } // endif
  4886.  
  4887.         if ( !poi->hItem ){
  4888.            WinReleasePS(hps);
  4889.            return (MRESULT)FALSE;
  4890.         } // endif
  4891.  
  4892.         /*---------------- Non-SPACER item to be drawn ------------------*/
  4893.  
  4894.         /* Note we completely redraw the item on all WM_DRAWITEM messages */
  4895.         /* even if only a state change.  Our state drawings require       */
  4896.         /* repainting to change states.                                   */
  4897.  
  4898.         WinFillRect(hps, &poi->rclItem, ItemBgColorIndex);
  4899.  
  4900.         /* Draw the bitmap into the drawing rectangle.  For hilight state */
  4901.         /* we draw it 1 pixel down and right of the usual position.       */
  4902.  
  4903.         UCMenuCalcBmpPos( poi, hwnd, UCMData->Style, aptlPoints, UCMData );
  4904.  
  4905.         if (poi->fsAttribute & MIA_HILITED) {
  4906.           aptlPoints[0].x++;
  4907.           aptlPoints[1].x++;
  4908.           aptlPoints[0].y--;
  4909.           aptlPoints[1].y--;
  4910.         }
  4911.  
  4912.         if ( !(UCMData->Style&UCS_SHRINK_BLEND)) {
  4913.            flOptions = BBO_IGNORE;
  4914.         } else {
  4915.            flOptions = UCMData->Style&UCS_SHRINK_OR ? BBO_OR : BBO_AND;
  4916.         } // endif
  4917.  
  4918.         GpiWCBitBlt( hps,
  4919.                      ITEM(poi, hBmp),
  4920.                      4,
  4921.                      aptlPoints,
  4922.                      ROP_SRCCOPY,
  4923.                      flOptions );
  4924.  
  4925.         /* Now draw the text, also down/right in hilight state */
  4926.  
  4927.         UCMenuCalcTextSize( (PUCMITEM) poi->hItem, hwnd, &TextWidth, &TextHeight);
  4928.  
  4929.         pszText = ITEM(poi, pszText);
  4930.         if (pszText && !(UCMData->Style & UCS_NOTEXT)) {
  4931.            RECTL rect;
  4932.            GpiSetColor(hps, SYSCLR_MENUTEXT);
  4933.  
  4934.            rect.xLeft   = poi->rclItem.xLeft   + ITEM_FRAME_THICK_LEFT;
  4935.            rect.xRight  = poi->rclItem.xRight  - ITEM_FRAME_THICK_RIGHT;
  4936.            rect.yBottom = poi->rclItem.yBottom + ITEM_FRAME_THICK_BOTTOM;
  4937.            rect.yTop    = rect.yBottom + TextHeight;
  4938.            if (poi->fsAttribute & MIA_HILITED) {
  4939.              rect.xLeft++;   // adjust target of text
  4940.              rect.xRight++;
  4941.              rect.yBottom--;
  4942.              rect.yTop--;
  4943.            }
  4944.            WinDrawText(hps, -1, pszText, &rect, 0, 0,
  4945.                        DT_CENTER | DT_VCENTER | DT_TEXTATTRS | DT_MNEMONIC);
  4946.         } // endif
  4947.  
  4948.         /* For checked state, draw thick border */
  4949.  
  4950.         if (  ( poi->fsAttribute & MIA_CHECKED ) ) {
  4951.            // Make it 1 pel thicker than frame to keep visible when HILITED
  4952.            WinDrawBorder( hps,
  4953.                           &(poi->rclItem),
  4954.                           ITEM_FRAME_THICK_LEFT+1,
  4955.                           ITEM_FRAME_THICK_TOP+1,
  4956.                           CLR_BLACK, CLR_BLACK,
  4957.                           DB_PATCOPY);
  4958.         } // endif
  4959.  
  4960.         /* Draw a frame  around the item or erase any hilight frame if the */
  4961.         /* style bits indicate items are not to be framed.                 */
  4962.  
  4963.         if (UCMData->Style & UCS_FRAMED)
  4964.            UCMenu3DFrame( hps,& poi->rclItem, poi->fsAttribute & MIA_HILITED);
  4965.         else {
  4966.            if (poi->fsAttribute & MIA_HILITED)  // Always draw depressed hilite frame
  4967.              UCMenu3DFrame(hps, &poi->rclItem, TRUE);
  4968.            else
  4969.              WinDrawBorder( hps,                // Erase any frame
  4970.                           &(poi->rclItem),
  4971.                           1L, 1L,
  4972.                           ItemBgColorIndex, ItemBgColorIndex,
  4973.                           DB_PATCOPY);
  4974.              }
  4975.  
  4976.         /* If item is disabled, shade the area with a half-tone background    */
  4977.         /* color pattern.  Note that PM also does this under some conditions, */
  4978.         /* but not when we redraw the item due to a state change.  PM does    */
  4979.         /* not seem to honor our clearing of the MIA_DISABLED bits (PM bug?)  */
  4980.         /* In general we cannot predict when PM will or will not provide the  */
  4981.         /* disable half-tone, so we always do it ourselves.                   */
  4982.  
  4983.         if (poi->fsAttribute & MIA_DISABLED) {
  4984.           POINTL BoxCorner;
  4985.           GpiSetPattern(hps, PATSYM_HALFTONE);  // Setup background halftone pattern
  4986.           GpiSetColor(hps, ItemBgColorIndex);
  4987.           GpiBeginArea(hps, BA_NOBOUNDARY);
  4988.           BoxCorner.x = poi->rclItem.xLeft+1;   // Don't halftone the frame
  4989.           BoxCorner.y = poi->rclItem.yBottom+1;
  4990.           GpiMove(hps, &BoxCorner);
  4991.           BoxCorner.x = poi->rclItem.xRight-2;  // Border pixel included, and 1 for frame
  4992.           BoxCorner.y = poi->rclItem.yTop-2;
  4993.           GpiBox(hps, DRO_OUTLINE, &BoxCorner, 0L, 0L);
  4994.           GpiEndArea(hps);
  4995.         }
  4996.   
  4997.          /* Clear all attribute bits since we do all rendering of attributes */
  4998.          /* and we don't want PM do modify our drawing.  PM seems to not     */
  4999.          /* honor this for MIA_DISABLED (see above).                         */
  5000.  
  5001.          poi->fsAttribute    = poi->fsAttribute    & ~(MIA_CHECKED|MIA_HILITED|MIA_FRAMED|MIA_DISABLED);
  5002.          poi->fsAttributeOld = poi->fsAttributeOld & ~(MIA_CHECKED|MIA_HILITED|MIA_FRAMED|MIA_DISABLED);
  5003.  
  5004.          WinReleasePS(hps);
  5005.          return (MRESULT)TRUE; /* TRUE means the item is drawn. */
  5006.  
  5007.       } // end of WM_DRAWITEM
  5008.  
  5009.     case WM_COMMAND:
  5010.       switch (SHORT1FROMMP(mp1)) {
  5011.         default:
  5012.           if ( SHORT1FROMMP( mp2 ) == CMDSRC_MENU ){
  5013.             MENUITEM mi;
  5014.             BOOL bButton2Down=0;
  5015.             LONG ButtonState;
  5016.    
  5017.             WinSendMsg(UCMData->hwndMenu,
  5018.                        MM_QUERYITEM,
  5019.                        MPFROM2SHORT(SHORT1FROMMP(mp1), TRUE),
  5020.                        MPFROMP(&mi));
  5021.    
  5022.             ButtonState = WinGetPhysKeyState(HWND_DESKTOP, VK_BUTTON2);
  5023.             if(ButtonState & 0x8000) {
  5024.               bButton2Down = 1;
  5025.             }
  5026.    
  5027.             /* (MAM)Dismiss any open submenu unless this item has MIA_NODISMISS attribute */
  5028.             /* since we force all submenus to be globally NODISMISS.                      */
  5029.             if ((!(mi.afAttribute & MIA_NODISMISS)) && (!bButton2Down))
  5030.               WinSendMsg(UCMData->hwndMenu, MM_ENDMENUMODE, MPFROMSHORT(TRUE), 0L);
  5031.    
  5032.             if ( !( UCMData->Style & UCS_NODEFAULTACTION ) &&
  5033.                  !bButton2Down &&
  5034.                  mi.hItem &&
  5035.                  ITEM( &mi, pszAction ) &&
  5036.                  strstr( ITEM( &mi, pszAction ), UCM_ACTION_EXEC ) == ITEM( &mi, pszAction ) ){
  5037.               PSZ pszParams = ITEM( &mi, pszParameters );
  5038.               PSZ pszParams2;
  5039.               if ( pszParams ){
  5040.                  PSZ const pszCmd = "CMD.EXE /K ";
  5041.                  TID tid;
  5042.                  pszParams += strspn( pszParams, " \t" );
  5043.                  pszParams2 = MyMalloc( strlen( pszParams ) + strlen( pszCmd ) + 1 );
  5044.                  if ( pszParams2 ) {
  5045.                     char * cmdext;
  5046.                     char * firstspace;
  5047.                     strcpy( pszParams2, pszParams );
  5048.                     strupr( pszParams2 );
  5049.                     cmdext = strstr( pszParams2, ".CMD" );
  5050.                     firstspace = strpbrk( pszParams2, " \t" );
  5051.                     if ( cmdext && ( !firstspace || ( firstspace > cmdext ) ) ){
  5052.                        strcpy( pszParams2, pszCmd );
  5053.                     } else {
  5054.                        *pszParams2 = '\0';
  5055.                     } // endif
  5056.                     strcat( pszParams2, pszParams );
  5057.                  } // endif
  5058.                  // pszParams2 will be freed by UCMenuExecuteProgram
  5059.                  DosCreateThread(&tid, (PFNTHREAD)UCMenuExecuteProgram, (ULONG)pszParams2, 0, 4096) ;
  5060.               } // endif
  5061.             } else {
  5062.               if (!bButton2Down) {
  5063.                  UCMITEM ucmi;
  5064.     
  5065.                  memset( &ucmi, '\0', sizeof( UCMITEM ) );
  5066.                  ucmi = *((PUCMITEM)( mi.hItem ) );
  5067.                  if ( ITEM( &mi, pszBmp ) ){
  5068.                     ucmi.pszBmp = MyStrdup( ITEM( &mi, pszBmp ) );
  5069.                  } // endif
  5070.                  if ( ITEM( &mi, pszText ) ){
  5071.                     ucmi.pszText = MyStrdup( ITEM( &mi, pszText ) );
  5072.                  } // endif
  5073.                  if ( ITEM( &mi, pszAction ) ){
  5074.                     ucmi.pszAction = MyStrdup( ITEM( &mi, pszAction ) );
  5075.                  } // endif
  5076.                  if ( ITEM( &mi, pszParameters ) ){
  5077.                     ucmi.pszParameters = MyStrdup( ITEM( &mi, pszParameters ) );
  5078.                  } // endif
  5079.                  if ( ITEM( &mi, pszData ) ){
  5080.                     ucmi.pszData = MyStrdup( ITEM( &mi, pszData ) );
  5081.                  } // endif
  5082.     
  5083.                  ucmi.usId = (USHORT)mp1;
  5084.     
  5085.                  WinSendMsg( UCMData->hwndOwner, WM_CONTROL,
  5086.                              MPFROM2SHORT(UCMData->UCMenuID, UCN_ITEMSELECTED ),
  5087.                              MPFROMP( &ucmi ) );
  5088.                  if ( ucmi.pszBmp ){
  5089.                     MyFree( ucmi.pszBmp );
  5090.                  } // endif
  5091.                  if ( ucmi.pszText ){
  5092.                     MyFree( ucmi.pszText );
  5093.                  } // endif
  5094.                  if ( ucmi.pszAction ){
  5095.                     MyFree( ucmi.pszAction );
  5096.                  } // endif
  5097.                  if ( ucmi.pszParameters ){
  5098.                     MyFree( ucmi.pszParameters );
  5099.                  } // endif
  5100.                  if ( ucmi.pszData ){
  5101.                     MyFree( ucmi.pszData );
  5102.                  } // endif
  5103.               } // endif
  5104.             } /* endif */
  5105.    
  5106.           } /* endif */
  5107.           break;
  5108.       } /* endswitch */
  5109.       break;
  5110.  
  5111.     case WM_HELP:
  5112.       mp1 = MPFROM2SHORT( SHORT1FROMMP(mp1), (USHORT)(UCMData->UCMenuID) );
  5113.       mp2 = MPFROM2SHORT( CMDSRC_UCMENU, SHORT2FROMMP(mp2) );
  5114.       WinPostMsg(UCMData->hwndOwner, msg, mp1, mp2);
  5115.       break;
  5116.  
  5117.     case WM_NEXTMENU:
  5118.       return WinSendMsg(UCMData->hwndOwner, msg, mp1, mp2);
  5119.  
  5120.     case WM_MENUSELECT:
  5121.       mp2 = MPFROMHWND(hwnd);
  5122.       WinPostMsg(UCMData->hwndOwner, msg, mp1, mp2);
  5123.       return (MRESULT)TRUE;
  5124.  
  5125.     case MM_INSERTITEM:
  5126.     case MM_SETITEM:
  5127.        {
  5128.           PMENUITEM pMi;
  5129.           MRESULT rc;
  5130.           USHORT  NotifyMsg;
  5131.  
  5132.           if ( msg == MM_INSERTITEM ) {
  5133.              pMi = (PMENUITEM)mp1;
  5134.           } else {
  5135.              pMi = (PMENUITEM)mp2;
  5136.           } // endif
  5137.  
  5138.           if ( pMi->hwndSubMenu ){
  5139.  
  5140.              // -- When we insert a submenu, we have to make sure that the submenu window
  5141.              // --  is associated with the right id and UCMData (in case it comes from another
  5142.              // --  UCMenu)
  5143.              PUCMDATA UCMDataSub = (PUCMDATA)WinQueryWindowULong( pMi->hwndSubMenu, QWL_USER );
  5144.  
  5145.              if ( !UCMDataSub || ( UCMDataSub != UCMData ) ){
  5146.                 PFNWP pFnwp;
  5147.                 pFnwp = (PFNWP)WinQueryWindowPtr( pMi->hwndSubMenu, QWP_PFNWP );
  5148.                 if ( pFnwp != SubmenuWndProc ){
  5149.                    UCMData->OldSubMenuProc = pFnwp;
  5150.                 } else if ( UCMDataSub ){
  5151.                    UCMData->OldSubMenuProc = UCMDataSub->OldSubMenuProc;
  5152.                 } // endif
  5153.                 WinSetWindowULong(  pMi->hwndSubMenu, QWL_USER, (ULONG)UCMData);
  5154.                 WinSetWindowUShort( pMi->hwndSubMenu, QWS_ID,   pMi->id);
  5155.                 WinSetOwner( pMi->hwndSubMenu, UCMData->hwndMenu );
  5156.                 // PRESPARAMCHANGED has to be processed by the original wnd proc
  5157.                 WinSubclassWindow( pMi->hwndSubMenu, UCMData->OldSubMenuProc );
  5158.                 WinSetPresParam( pMi->hwndSubMenu, PP_MENUBACKGROUNDCOLOR, sizeof UCMData->ItemBgColor, &(UCMData->ItemBgColor) );
  5159.                 WinSetPresParam( pMi->hwndSubMenu, PP_FONTNAMESIZE,
  5160.                                  strlen( UCMData->pszFontNameSize ) + 1, UCMData->pszFontNameSize );
  5161.                 WinSubclassWindow( pMi->hwndSubMenu, SubmenuWndProc );
  5162.                 // The parent is the desktop, so it doesn't change
  5163.              } // endif
  5164.           } // endif
  5165.  
  5166.           if (UCMData->usItem != 0) {   //(MAM) There is an open submenu, close it
  5167.              MENUITEM OpenItem;
  5168.              if ((BOOL)WinSendMsg(UCMData->hwndMenu,
  5169.                         MM_QUERYITEM,
  5170.                         MPFROM2SHORT(UCMData->usItem,TRUE),
  5171.                         MPFROMP(&OpenItem)))
  5172.                WinSendMsg(OpenItem.hwndSubMenu, MM_ENDMENUMODE, MPFROMSHORT(TRUE), 0L);
  5173.           }
  5174.        
  5175.           rc = SEND_TO_MENU;
  5176.  
  5177.           UCMenuUpdateMenu( UCMData->hwndMenu, FALSE );
  5178.  
  5179.           /* Tell owner of change */
  5180.           if ( msg == MM_INSERTITEM )
  5181.             NotifyMsg = UCN_ADDEDITEM;
  5182.           else
  5183.             NotifyMsg = UCN_CHANGEDITEM;
  5184.           WinSendMsg( UCMData->hwndOwner,
  5185.                       WM_CONTROL,
  5186.                       MPFROM2SHORT(UCMData->UCMenuID, NotifyMsg ),
  5187.                       MPFROMSHORT(pMi->id));
  5188.  
  5189.           return rc;
  5190.        }
  5191.  
  5192.     //(MAM) Removed fall-through of case from above.
  5193.  
  5194.     case MM_DELETEITEM:
  5195.     case MM_REMOVEITEM:
  5196.     case MM_SETITEMHANDLE:
  5197.       { MRESULT rc;
  5198.         MENUITEM mi;
  5199.         USHORT  NotifyMsg;
  5200.  
  5201.         if (UCMData->usItem != 0) {   //(MAM) There is an open submenu, close it
  5202.            MENUITEM OpenItem;
  5203.            if ((BOOL)WinSendMsg(UCMData->hwndMenu,
  5204.                       MM_QUERYITEM,
  5205.                       MPFROM2SHORT(UCMData->usItem,TRUE),
  5206.                       MPFROMP(&OpenItem)))
  5207.              WinSendMsg(OpenItem.hwndSubMenu, MM_ENDMENUMODE, MPFROMSHORT(TRUE), 0L);
  5208.         }
  5209.  
  5210.         //(MAM) Don't process delete on submenus here -- submenu window proc will do it.
  5211.         if (!(BOOL)WinSendMsg(UCMData->hwndMenu, MM_QUERYITEM, MPFROM2SHORT(SHORT1FROMMP(mp1),FALSE), MPFROMP(&mi)))
  5212.           return SEND_TO_MENU;
  5213.  
  5214.         if ( msg == MM_DELETEITEM ) {
  5215.            if ( mi.hItem ){
  5216.               if ( ITEM( &mi, pszBmp ) ){
  5217.                 MyFree( ITEM( &mi, pszBmp ) );
  5218.               }
  5219.               if ( ITEM( &mi, pszText ) ){
  5220.                 MyFree( ITEM( &mi, pszText ) );
  5221.               }
  5222.               if ( ITEM( &mi, pszAction ) ){
  5223.                 MyFree( ITEM( &mi, pszAction ) );
  5224.               }
  5225.               if ( ITEM( &mi, pszData ) ){
  5226.                 MyFree( ITEM( &mi, pszData ) );
  5227.               }
  5228.               if ( ITEM( &mi, pszParameters ) ){
  5229.                 MyFree( ITEM( &mi, pszParameters ) );
  5230.               }
  5231.               if ( ITEM( &mi, hBmp ) ){
  5232.                 GpiDeleteBitmap( ITEM( &mi, hBmp ) );
  5233.               }
  5234.               MyFree( (PVOID)mi.hItem );
  5235.               if ( mi.hwndSubMenu ){
  5236.                  UCMenuFreeMenuData( mi.hwndSubMenu );
  5237.               } // endif
  5238.            } // endif
  5239.         } // endif
  5240.  
  5241.         //(MAM) Moved outside above IF so owner is notified of DELETE or REMOVEs
  5242.        
  5243.         if ((msg==MM_DELETEITEM) || (msg==MM_REMOVEITEM))
  5244.           NotifyMsg = UCN_DELETEDITEM;
  5245.         else
  5246.           NotifyMsg = UCN_CHANGEDITEM;
  5247.         WinSendMsg(UCMData->hwndOwner,
  5248.                    WM_CONTROL,
  5249.                    MPFROM2SHORT(UCMData->UCMenuID, NotifyMsg ),
  5250.                    MPFROMSHORT( SHORT1FROMMP( mp1 ) ) );
  5251.  
  5252.         rc = SEND_TO_MENU;
  5253.  
  5254.         UCMenuUpdateMenu( UCMData->hwndMenu, FALSE );
  5255.  
  5256.         return rc;
  5257.       }
  5258.  
  5259.     case MM_SETITEMATTR:
  5260.     case MM_ENDMENUMODE:
  5261.     case MM_ISITEMVALID:
  5262.     case MM_ITEMIDFROMPOSITION:
  5263.     case MM_ITEMPOSITIONFROMID:
  5264.     case MM_QUERYITEM:
  5265.     case MM_QUERYITEMATTR:
  5266.     case MM_QUERYITEMCOUNT:
  5267.     case MM_QUERYITEMRECT:
  5268.     case MM_QUERYSELITEMID:
  5269.     case MM_SELECTITEM:
  5270.     case WM_QUERYCONVERTPOS:
  5271.     case WM_SETWINDOWPARAMS:
  5272.     case WM_QUERYWINDOWPARAMS:
  5273.       return SEND_TO_MENU;
  5274.  
  5275.     case MM_STARTMENUMODE:
  5276.       return POST_TO_MENU;
  5277.  
  5278.     case MM_QUERYITEMTEXTLENGTH:
  5279.       { MENUITEM mi;
  5280.  
  5281.         WinSendMsg(UCMData->hwndMenu,
  5282.                    MM_QUERYITEM,
  5283.                    MPFROM2SHORT((SHORT)mp1, TRUE),
  5284.                    MPFROMP(&mi));
  5285.  
  5286.         if ( ! ( mi.afStyle & MIS_OWNERDRAW ) ) {
  5287.           return SEND_TO_MENU;
  5288.         } else {
  5289.           if (mi.hItem && ITEM(&mi, pszText))
  5290.             return (MPARAM)strlen(ITEM(&mi, pszText));
  5291.           else
  5292.             return (MPARAM)0;
  5293.         } // endif
  5294.       }
  5295.  
  5296.     case MM_QUERYITEMTEXT:
  5297.       { MENUITEM mi;
  5298.  
  5299.         if (!SHORT2FROMMP(mp1) || !mp2) {
  5300.           return FALSE;
  5301.         } // endif
  5302.         WinSendMsg(UCMData->hwndMenu,
  5303.                    MM_QUERYITEM,
  5304.                    MPFROM2SHORT((SHORT)mp1, TRUE),
  5305.                    MPFROMP(&mi));
  5306.  
  5307.         if ( ! ( mi.afStyle & MIS_OWNERDRAW ) ) {
  5308.           return SEND_TO_MENU;
  5309.         } else {
  5310.           PSZ pszText;
  5311.  
  5312.           if (mi.hItem && (pszText = ITEM(&mi, pszText))) {
  5313.             strncpy((PSZ)mp2, pszText, SHORT2FROMMP(mp1));
  5314.             pszText[SHORT2FROMMP(mp1)]='\0';
  5315.             return (MRESULT)strlen(pszText);
  5316.           } else {
  5317.             return (MRESULT)0;
  5318.           } /* endif */
  5319.         } /* endif */
  5320.       }
  5321.  
  5322.     case MM_SETITEMTEXT:
  5323.       { MENUITEM mi;
  5324.  
  5325.         WinSendMsg(UCMData->hwndMenu,
  5326.                    MM_QUERYITEM,
  5327.                    MPFROM2SHORT((SHORT)mp1, TRUE),
  5328.                    MPFROMP(&mi));
  5329.  
  5330.         if ( ! ( mi.afStyle & MIS_OWNERDRAW ) ) {
  5331.           return SEND_TO_MENU;
  5332.         } else {
  5333.           if (mi.hItem) {
  5334.             PSZ pszText = ITEM(&mi, pszText);
  5335.  
  5336.             if (pszText)
  5337.               MyFree(pszText);
  5338.             pszText = MyMalloc(strlen((PSZ)mp2)+1);
  5339.             strcpy(pszText, (PSZ)mp2);
  5340.             ITEM(&mi, pszText) = pszText;
  5341.             WinSendMsg( UCMData->hwndOwner,
  5342.                     WM_CONTROL,
  5343.                     MPFROM2SHORT(UCMData->UCMenuID, UCN_TEXT ),
  5344.                     MPFROMSHORT( mi.id ) );
  5345.             UCMenuUpdateMenu( UCMData->hwndMenu, TRUE );
  5346.             return (MRESULT)TRUE;
  5347.           } else {
  5348.             return (MRESULT)FALSE;
  5349.           } /* endif */
  5350.         } /* endif */
  5351.       }
  5352.  
  5353.     /*┌────────────────────┐
  5354.       │ Scrolling messages │
  5355.       └────────────────────┘*/
  5356.     case WM_VSCROLL:
  5357.       /*┌─────────────────────────┐
  5358.         │ Vertical Scroll message │
  5359.         └─────────────────────────┘*/
  5360.       switch (SHORT2FROMMP(mp2)) {
  5361.         case SB_LINEDOWN:
  5362.           /*┌────────────────────────────────────────────────────────────┐
  5363.             │ SB_LINEDOWN : We query the first item height and use it to │
  5364.             │ scroll the menu up                                         │
  5365.             └────────────────────────────────────────────────────────────┘*/
  5366.           { SWP swp;
  5367.             SHORT SliderPos;
  5368.             SHORT MaxPos;
  5369.             LONG  deltay;
  5370.  
  5371.             WinQueryWindowPos(UCMData->hwndHide, &swp );
  5372.  
  5373.             deltay = ( swp.cy - SUM_MENU_FRAME_THICK ) / 2;
  5374.  
  5375.             /*┌────────────────────────────────────────┐
  5376.               │ Query the scrollbar range and position │
  5377.               └────────────────────────────────────────┘*/
  5378.             MaxPos = SHORT2FROMMP(WinSendMsg(UCMData->hwndScroll,
  5379.                                              SBM_QUERYRANGE,
  5380.                                              (MPARAM)0,
  5381.                                              (MPARAM)0));
  5382.             SliderPos = (SHORT)WinSendMsg(UCMData->hwndScroll,
  5383.                                           SBM_QUERYPOS,
  5384.                                           (MPARAM)0,
  5385.                                           (MPARAM)0);
  5386.  
  5387.             /*┌────────────────────────────────────────────────────────┐
  5388.               │ Set the new position : don't scroll beyond the maximum │
  5389.               └────────────────────────────────────────────────────────┘*/
  5390.             if (SliderPos + deltay > MaxPos) {
  5391.               deltay -= SliderPos + deltay - MaxPos;
  5392.             } /* endif */
  5393.  
  5394.             WinPostMsg(UCMData->hwndScroll,
  5395.                        SBM_SETPOS,
  5396.                        MPFROMSHORT(SliderPos + deltay),
  5397.                        (MPARAM)0);
  5398.  
  5399.             WinQueryWindowPos(UCMData->hwndMenu, &swp);
  5400.             WinSetWindowPos(UCMData->hwndMenu,
  5401.                             HWND_TOP,
  5402.                             swp.x,
  5403.                             swp.y + deltay,
  5404.                             0,
  5405.                             0,
  5406.                             SWP_MOVE|SWP_SHOW);
  5407.           } break;
  5408.  
  5409.         case SB_LINEUP:
  5410.           /*┌────────────────────────────────────────────────────────────┐
  5411.             │ SB_LINEUP : We query the first item height and use it to   │
  5412.             │ scroll the menu down                                       │
  5413.             └────────────────────────────────────────────────────────────┘*/
  5414.           { SWP   swp;
  5415.             SHORT SliderPos;
  5416.             SHORT MinPos;
  5417.             LONG  deltay;
  5418.  
  5419.             WinQueryWindowPos( UCMData->hwndHide, &swp );
  5420.  
  5421.             deltay = ( swp.cy - SUM_MENU_FRAME_THICK ) / 2;
  5422.  
  5423.             /*┌────────────────────────────────────────┐
  5424.               │ Query the scrollbar range and position │
  5425.               └────────────────────────────────────────┘*/
  5426.             MinPos = SHORT1FROMMP(WinSendMsg(UCMData->hwndScroll,
  5427.                                              SBM_QUERYRANGE,
  5428.                                              (MPARAM)0,
  5429.                                              (MPARAM)0));
  5430.             SliderPos = (SHORT)WinSendMsg(UCMData->hwndScroll,
  5431.                                           SBM_QUERYPOS,
  5432.                                           (MPARAM)0,
  5433.                                           (MPARAM)0);
  5434.  
  5435.             /*┌───────────────────────────────────────────────────┐
  5436.               │ Set the new position : don't scroll < the minimum │
  5437.               └───────────────────────────────────────────────────┘*/
  5438.             if (SliderPos - deltay < MinPos) {
  5439.               deltay -= MinPos - SliderPos + deltay;
  5440.             } /* endif */
  5441.  
  5442.             WinPostMsg(UCMData->hwndScroll,
  5443.                        SBM_SETPOS,
  5444.                        MPFROMSHORT(SliderPos - deltay),
  5445.                        (MPARAM)0);
  5446.  
  5447.             WinQueryWindowPos(UCMData->hwndMenu, &swp);
  5448.             WinSetWindowPos(UCMData->hwndMenu,
  5449.                             HWND_TOP,
  5450.                             swp.x,
  5451.                             swp.y - deltay,
  5452.                             0,
  5453.                             0,
  5454.                             SWP_MOVE|SWP_SHOW);
  5455.           } break;
  5456.       } /* endswitch */
  5457.       break;
  5458.  
  5459.     case WM_HSCROLL:
  5460.       /*┌───────────────────────────┐
  5461.         │ Horizontal Scroll message │
  5462.         └───────────────────────────┘*/
  5463.       switch (SHORT2FROMMP(mp2)) {
  5464.         case SB_LINERIGHT:
  5465.           /*┌────────────────────────────────────────────────────────────┐
  5466.             │ SB_LINERIGHT: We query the first item width and use it to  │
  5467.             │ scroll the menu to the left                                │
  5468.             └────────────────────────────────────────────────────────────┘*/
  5469.           { SWP swp;
  5470.             SHORT SliderPos;
  5471.             SHORT MaxPos;
  5472.             LONG  deltax;
  5473.  
  5474.             WinQueryWindowPos( UCMData->hwndHide, &swp );
  5475.  
  5476.             deltax = ( swp.cx - SUM_MENU_FRAME_THICK ) / 2;
  5477.  
  5478.             /*┌────────────────────────────────────────┐
  5479.               │ Query the scrollbar range and position │
  5480.               └────────────────────────────────────────┘*/
  5481.             MaxPos = SHORT2FROMMP(WinSendMsg(UCMData->hwndScroll,
  5482.                                              SBM_QUERYRANGE,
  5483.                                              (MPARAM)0,
  5484.                                              (MPARAM)0));
  5485.             SliderPos = (SHORT)WinSendMsg(UCMData->hwndScroll,
  5486.                                           SBM_QUERYPOS,
  5487.                                           (MPARAM)0,
  5488.                                           (MPARAM)0);
  5489.  
  5490.             /*┌────────────────────────────────────────────────────────┐
  5491.               │ Set the new position : don't scroll beyond the maximum │
  5492.               └────────────────────────────────────────────────────────┘*/
  5493.             if (SliderPos + deltax > MaxPos) {
  5494.               deltax -= SliderPos + deltax - MaxPos;
  5495.             } /* endif */
  5496.  
  5497.             WinPostMsg(UCMData->hwndScroll,
  5498.                        SBM_SETPOS,
  5499.                        MPFROMSHORT(SliderPos + deltax),
  5500.                        (MPARAM)0);
  5501.  
  5502.             WinQueryWindowPos(UCMData->hwndMenu, &swp);
  5503.             WinSetWindowPos(UCMData->hwndMenu,
  5504.                             HWND_TOP,
  5505.                             swp.x - deltax,
  5506.                             swp.y,
  5507.                             0,
  5508.                             0,
  5509.                             SWP_MOVE|SWP_SHOW);
  5510.           } break;
  5511.  
  5512.         case SB_LINELEFT:
  5513.           /*┌────────────────────────────────────────────────────────────┐
  5514.             │ SB_LINELEFT: We query the first item width  and use it to  │
  5515.             │ scroll the menu right                                      │
  5516.             └────────────────────────────────────────────────────────────┘*/
  5517.           { SWP   swp;
  5518.             SHORT SliderPos;
  5519.             SHORT MinPos;
  5520.             LONG  deltax;
  5521.  
  5522.             WinQueryWindowPos( UCMData->hwndHide, &swp );
  5523.  
  5524.             deltax = ( swp.cx - SUM_MENU_FRAME_THICK ) / 2;
  5525.  
  5526.             /*┌────────────────────────────────────────┐
  5527.               │ Query the scrollbar range and position │
  5528.               └────────────────────────────────────────┘*/
  5529.             MinPos = SHORT1FROMMP(WinSendMsg(UCMData->hwndScroll,
  5530.                                              SBM_QUERYRANGE,
  5531.                                              (MPARAM)0,
  5532.                                              (MPARAM)0));
  5533.             SliderPos = (SHORT)WinSendMsg(UCMData->hwndScroll,
  5534.                                           SBM_QUERYPOS,
  5535.                                           (MPARAM)0,
  5536.                                           (MPARAM)0);
  5537.  
  5538.             /*┌────────────────────────────────────────────────────────┐
  5539.               │ Set the new position : don't scroll beyond the minimum │
  5540.               └────────────────────────────────────────────────────────┘*/
  5541.             if (SliderPos - deltax < MinPos) {
  5542.               deltax -= MinPos - SliderPos + deltax;
  5543.             } /* endif */
  5544.  
  5545.             WinPostMsg(UCMData->hwndScroll,
  5546.                        SBM_SETPOS,
  5547.                        MPFROMSHORT(SliderPos - deltax),
  5548.                        (MPARAM)0);
  5549.  
  5550.             WinQueryWindowPos(UCMData->hwndMenu, &swp);
  5551.             WinSetWindowPos(UCMData->hwndMenu,
  5552.                             HWND_TOP,
  5553.                             swp.x + deltax,
  5554.                             swp.y,
  5555.                             0,
  5556.                             0,
  5557.                             SWP_MOVE|SWP_SHOW);
  5558.           } break;
  5559.       } /* endswitch */
  5560.       break;
  5561.  
  5562.     case WM_ADJUSTWINDOWPOS:
  5563.       { PSWP pswp = (PSWP)mp1;
  5564.  
  5565.         if (pswp->fl & (SWP_MOVE | SWP_SIZE)) {
  5566.           //(MAM) changed this from Post to Send to prevent delayed repainting
  5567.           WinSendMsg(hwnd,                                
  5568.                      WM_SIZE,
  5569.                      (MPARAM)0,
  5570.                      MPFROM2SHORT(pswp->cx, pswp->cy));
  5571.         } /* endif */
  5572.  
  5573.         if (pswp->fl & SWP_ACTIVATE) {
  5574.           pswp->fl &= (ULONG)~SWP_ACTIVATE;
  5575.           WinSetWindowPos(hwnd,
  5576.                           HWND_TOP,
  5577.                           0,
  5578.                           0,
  5579.                           0,
  5580.                           0,
  5581.                           SWP_ZORDER | SWP_ACTIVATE);
  5582.         } /* endif */
  5583.       } break;
  5584.  
  5585.     case WM_SIZE:
  5586.     { //SWP swp;
  5587.       LONG  cx = SHORT1FROMMP(mp2);
  5588.       LONG  cy = SHORT2FROMMP(mp2);
  5589.  
  5590.       if (cx<=0 || cy<=0 || !(UCMData->hwndScroll) || !(UCMData->hwndHide) || !(UCMData->hwndMenu)) break;
  5591.  
  5592. //    WinQueryWindowPos(UCMData->hwndMenu, &swp);
  5593.  
  5594.       /* Set scroll window over entire area */
  5595.       WinSetWindowPos(UCMData->hwndScroll,
  5596.                       HWND_TOP,
  5597.                       0,
  5598.                       0,
  5599.                       cx,
  5600.                       cy,
  5601.                       SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW);
  5602.  
  5603.       /* Set hide to cover area, inset by borders */
  5604.       WinSetWindowPos(UCMData->hwndHide,
  5605.                       HWND_TOP,
  5606.                       UCM_FRAME_THICK,
  5607.                       UCM_FRAME_THICK,
  5608.                       cx - SUM_UCM_FRAME_THICK,
  5609.                       cy - SUM_UCM_FRAME_THICK,
  5610.                       SWP_SIZE | SWP_MOVE | SWP_ZORDER | SWP_SHOW);
  5611.  
  5612.       //7@P5d Moved set of menu window position to UCMenuCheckScrolling()
  5613.  
  5614.       UCMenuCheckScrolling(hwnd);
  5615.     } break;
  5616.  
  5617.     case WM_SHOW:
  5618.       // We can get this message after WM_DESTROY has freed our
  5619.       // instance data, so check the pointer first!
  5620.       if (UCMData != NULL) {
  5621.         if (UCMData->hwndScroll)
  5622.           WinShowWindow(UCMData->hwndScroll, (BOOL)mp1);
  5623.   
  5624.         if (UCMData->hwndHide)
  5625.           WinShowWindow(UCMData->hwndHide, (BOOL)mp1);
  5626.   
  5627.         if (UCMData->hwndMenu)
  5628.           WinShowWindow(UCMData->hwndMenu, (BOOL)mp1);
  5629.       }
  5630.       break;
  5631.  
  5632.     case WM_DESTROY:
  5633.       {
  5634.  
  5635.         if (UCMData->usItem != 0) {   //(MAM) There is an open submenu, close it before destory
  5636.            MENUITEM OpenItem;
  5637.            if ((BOOL)WinSendMsg(UCMData->hwndMenu,
  5638.                       MM_QUERYITEM,
  5639.                       MPFROM2SHORT(UCMData->usItem,TRUE),
  5640.                       MPFROMP(&OpenItem)))
  5641.              WinSendMsg(OpenItem.hwndSubMenu, MM_ENDMENUMODE, MPFROMSHORT(TRUE), 0L);
  5642.         }
  5643.  
  5644.         WinSubclassWindow( UCMData->hwndMenu, (PFNWP)UCMData->OldMenuProc);
  5645.         if (UCMData->hwndHelpInstance) {
  5646.            WinDestroyHelpInstance( UCMData->hwndHelpInstance );
  5647.         } // endif
  5648.  
  5649.         UCMenuFreeMenuData( UCMData->hwndMenu );
  5650.         //free all UCMenu instance data
  5651.         if ( UCMData->pszFontNameSize ) {
  5652.            MyFree( UCMData->pszFontNameSize );
  5653.         } // endif
  5654.         if ( UCMData->hpsMem ) {
  5655.            HDC hdcMem;
  5656.            hdcMem = GpiQueryDevice( UCMData->hpsMem );
  5657.            //(MAM) Destroy PS before closing DC since PM cannot
  5658.            //disassociate a micro PS from its DC.
  5659.            GpiDestroyPS( UCMData->hpsMem );
  5660.            DevCloseDC( hdcMem );
  5661.         } // endif
  5662.         if ( UCMData->AccelTable ){
  5663.            MyFree( UCMData->AccelTable );
  5664.         } // endif
  5665.  
  5666.         //(MAM) destroy other windows also.  Since Scroll, Hide, and Menu windows are
  5667.         // child windows, they will be destroyed by PM after this message is processed.
  5668.         // We must explicitly destroy non-child windows:
  5669.  
  5670.         if ( UCMData->hwndCM )                   // context menu
  5671.           WinDestroyWindow( UCMData->hwndCM );
  5672.         if ( UCMData->hwndBubble )
  5673.           WinDestroyWindow(UCMData->hwndBubble); // bubble window
  5674.  
  5675.         WinSetWindowPtr(hwnd, QWL_UCMDATA, NULL);
  5676.         MyFree(UCMData);
  5677.         return 0;
  5678.       }
  5679.  
  5680.     default:
  5681.      return (WinDefWindowProc(hwnd, msg, mp1, mp2));
  5682.  
  5683.   } // endswitch
  5684.   return (MRESULT)FALSE;
  5685. }
  5686.  
  5687. //----------------------------------------------------------------------------
  5688. // HideWndProc
  5689. //----------------------------------------------------------------------------
  5690. // :pfunction res=&IDF_HIDEWNDPROC. name='HideWndProc' text='Hide window procedure'.
  5691. // Window procedure of the Hide class, processes WM_PAINT, WM_CONTEXT and WM_COMMAND
  5692. // :syntax name='HideWndProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  5693. // :fparams.
  5694. // :fparam name='hwnd' type='HWND' io='input' .
  5695. // Hide window handle
  5696. // :fparam name='msg' type='ULONG' io='input' .
  5697. // Message
  5698. // :fparam name='mp1' type='MPARAM' io='input'.
  5699. // First parameter
  5700. // :fparam name='mp2' type='MPARAM' io='input'.
  5701. // Second parameter
  5702. // :freturns.
  5703. // :fparam name='mresult' type='MRESULT' io='return'.
  5704. // Return code of a PM message.
  5705. // :efparams.
  5706. // :remarks.
  5707. // :epfunction.
  5708. //----------------------------------------------------------------------------
  5709. MRESULT EXPENTRY HideWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  5710. {
  5711. PUCMDATA UCMData;
  5712.  
  5713.   UCMData = WinQueryWindowPtr(hwnd, 0L);
  5714.  
  5715.   switch (msg) {
  5716.      case WM_PRESPARAMCHANGED:
  5717.           {
  5718.              if ( (SHORT)mp1 == PP_BACKGROUNDCOLOR ) {
  5719.                 ULONG Color, x;
  5720.                 HPS hps;
  5721.  
  5722.                 WinQueryPresParam( hwnd,
  5723.                                    (SHORT)mp1,
  5724.                                    0L, &x,
  5725.                                    (ULONG)sizeof Color,
  5726.                                    &Color,
  5727.                                    QPF_NOINHERIT);
  5728.                 if ( UCMData && ( x == (SHORT)mp1 ) ){
  5729.                    // We don't want a dithered color because we will also use it
  5730.                    // to draw lines, and in this case only pure colors are used
  5731.                    // -> we will to have exactly the same color all over the ucmenu
  5732.                    hps = WinGetPS( hwnd );
  5733.                    if ( hps ){
  5734.                       UCMData->BgColor = GpiQueryNearestColor( hps, (ULONG)0, (LONG)Color );
  5735.                       UCMenuUpdateMenu( UCMData->hwndMenu, FALSE );
  5736.                       WinReleasePS( hps );
  5737.                       WinSendMsg( UCMData->hwndOwner,
  5738.                                   WM_CONTROL,
  5739.                                   MPFROM2SHORT(UCMData->UCMenuID, UCN_COLOR ),
  5740.                                   MPFROMSHORT( 0 ) );
  5741.                    } // endif
  5742.                 } else {
  5743.                    WinRemovePresParam( hwnd, PP_BACKGROUNDCOLOR );
  5744.                 } // endif
  5745.              } else {
  5746.                 UCMenuPresParamChanged(UCMData, hwnd, mp1 );
  5747.              } // endif
  5748.              return((MRESULT)0);
  5749.           }
  5750. //  case WM_MOUSEMOVE:
  5751. //     {
  5752. //        PUCMDATA  UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  5753. //        if ( UCMData->Style & UCS_PROMPTING ){
  5754. //           HWND hwndUCM   = WinQueryWindow( hwnd, QW_OWNER );
  5755. //           HWND hwndOwner = WinQueryWindow( hwndUCM, QW_OWNER );
  5756. //           WinSendMsg( hwndOwner,
  5757. //                       WM_CONTROL,
  5758. //                       MPFROM2SHORT( WinQueryWindowUShort( hwndUCM, QWS_ID ), UCN_MOUSEMOVE ),
  5759. //                       (MPARAM)0);
  5760. //           return (MRESULT)TRUE;
  5761. //        } else {
  5762. //           return (MRESULT)FALSE;
  5763. //        } // endif
  5764. //     }
  5765.  
  5766.     case WM_CREATE:
  5767.  
  5768.          WinSetWindowPtr(hwnd, 0L, (PUCMDATA)mp1);
  5769.          return((MRESULT)0);
  5770.  
  5771. // case WM_INITMENU:
  5772. //    {
  5773. //       PUCMDATA UCMData = (PUCMDATA)mp1;
  5774. //
  5775. //       // ----------------------------------------------------------
  5776. //       // -- Received when the context menu is about to be displayed
  5777. //       // -- Set the scrollbar as active window so that the contextual
  5778. //       // -- help looks in its help subtable (this is the only
  5779. //       // -- frame window available with a fixed ID)
  5780. //       // ----------------------------------------------------------
  5781. //       WinSendMsg( UCMData->hwndHelpInstance,
  5782. //                   HM_SET_ACTIVE_WINDOW,
  5783. //                   (MPARAM) WinQueryWindow( hwnd, QW_PARENT ),
  5784. //                   (MPARAM) WinQueryWindow( hwnd, QW_PARENT ) );
  5785. //       return WinDefWindowProc( hwnd, msg, mp1, mp2);
  5786. //    }
  5787.    case WM_CONTEXTMENU:
  5788.  
  5789.       /*┌──────────────────────────────────────────────────────────────┐
  5790.         │ Show the pop-up menu                                         │
  5791.         └──────────────────────────────────────────────────────────────┘*/
  5792.       {
  5793.  
  5794.          UCMenuContextMenu(UCMData->hwndUCM,
  5795.                            UCMData->hwndMenu,
  5796.                            (ULONG)mp1);
  5797.          return (MRESULT) TRUE;
  5798.       }
  5799.  
  5800.     case WM_MENUEND:{
  5801.       /* Context menu is terminating... re-enable bubble help window */
  5802.       if (UCMData->Style & UCS_BUBBLEHELP)
  5803.         WinSendMsg(UCMData->hwndBubble, MSG_ENABLE_BUBBLE, 0L, 0L);
  5804.       return 0;
  5805.       }
  5806.  
  5807.     case WM_COMMAND: {
  5808.  
  5809.       /* We only get WM_COMMAND messages here from the toolbar context menu. */
  5810.       /* If the context menu is application-supplied, we just pass the       */
  5811.       /* message on to the application.  Otherwise, we process options on    */
  5812.       /* the built-in toolbar context menu.                                  */
  5813.       if (UCMData->hwndUserCM != NULLHANDLE) { // App supplied the context menu
  5814.  
  5815.         WinSendMsg(UCMData->hwndOwner,  // To owner (app)
  5816.                    WM_CONTROL,
  5817.                    MPFROM2SHORT( UCMData->UCMenuID, UCN_CMITEM ) ,
  5818.                    MPFROM2SHORT( SHORT1FROMMP( mp1 ), UCMData->ContextID  ) );
  5819.         return 0;
  5820.       }
  5821.  
  5822.       #if !defined(UCMUI)  // We don't support any UI functions
  5823.         return 0;
  5824.       #else
  5825.       switch (SHORT1FROMMP(mp1)) {
  5826.         case IDM_UCM_DELETE:
  5827.           {
  5828.             /*┌──────────────────────────────────────────────────────────────┐
  5829.               │ Delete the menu item (ContextID = itemID)                    │
  5830.               └──────────────────────────────────────────────────────────────┘*/
  5831.  
  5832.             WinSendMsg(UCMData->hwndCMOrig,
  5833.                        MM_DELETEITEM,
  5834.                        MPFROM2SHORT(UCMData->ContextID, TRUE),
  5835.                        (MPARAM)0);
  5836.           }
  5837.           return (MRESULT)TRUE;
  5838.  
  5839.         case IDM_UCM_CREATE:
  5840.           /*┌──────────────────────────────────────────────────────────────┐
  5841.             │ Add a new item in the UCMenu : use the settings notebook     │
  5842.             └──────────────────────────────────────────────────────────────┘*/
  5843.           {
  5844.  
  5845.             UCMData->bItemCreation = TRUE;
  5846.             UCMData->hwndTemp = WinQueryWindow(hwnd, QW_OWNER);
  5847.             WinDlgBox(HWND_DESKTOP,
  5848.                       UCMData->hwndTemp,  //---hwndUCM
  5849.                       UCMenuSettingsDlgProc,
  5850.                       UCMData->hModUCM,
  5851.                       IDD_UCMSETTINGS,
  5852.                       (PVOID)UCMData);
  5853.             UCMData->hwndTemp = NULLHANDLE;
  5854.           }
  5855.           return (MRESULT)TRUE;
  5856.  
  5857.         case IDM_UCM_EDIT:
  5858.           /*┌──────────────────────────────────────────────────────────────┐
  5859.             │ Edit an item : call the settings notebook                    │
  5860.             └──────────────────────────────────────────────────────────────┘*/
  5861.           {
  5862.  
  5863.             UCMData->bItemCreation = FALSE;
  5864.             UCMData->hwndTemp = WinQueryWindow(hwnd, QW_OWNER);
  5865.             WinDlgBox(HWND_DESKTOP,
  5866.                       UCMData->hwndTemp,  //---hwndUCM
  5867.                       UCMenuSettingsDlgProc,
  5868.                       UCMData->hModUCM,
  5869.                       IDD_UCMSETTINGS,
  5870.                       (PVOID)UCMData);
  5871.             UCMData->hwndTemp = NULLHANDLE;
  5872.           }
  5873.           return (MRESULT)TRUE;
  5874.  
  5875.         case IDM_UCM_DEFAULT:
  5876.           /*┌──────────────────────────────────────────────────────────────┐
  5877.             │ Get the default template (from the resource)                 │
  5878.             └──────────────────────────────────────────────────────────────┘*/
  5879.           UCMenuLoadDefault( UCMData->hwndUCM );
  5880.           break;
  5881.  
  5882.  
  5883.         case IDM_UCM_LOAD:
  5884.           /*┌──────────────────────────────────────────────────────────────┐
  5885.             │ Load a template from a file                                  │
  5886.             └──────────────────────────────────────────────────────────────┘*/
  5887.           { FILEDLG FileDlg;
  5888.             ULONG  ulBufLen;
  5889.             UCHAR  szPath[CCHMAXPATH];
  5890.             PSZ    pszIndex;
  5891.  
  5892.  
  5893.             UCMData->hwndTemp = WinQueryWindow(hwnd, QW_OWNER);
  5894.             szPath[CCHMAXPATH-1] = '\0';
  5895.             strncpy( szPath, UCMData->szTemplatePath, CCHMAXPATH );
  5896.             strncat( szPath, "*.bar", CCHMAXPATH );
  5897.             memset(&FileDlg, 0, sizeof(FileDlg));
  5898.             FileDlg.cbSize = sizeof(FileDlg);
  5899.             FileDlg.fl     = FDS_OPEN_DIALOG | FDS_CENTER;
  5900.             FileDlg.szFullFile[CCHMAXPATH-1] = '\0';
  5901.             strncpy( FileDlg.szFullFile, szPath, CCHMAXPATH );
  5902.             WinFileDlg(HWND_DESKTOP, hwnd, &FileDlg);
  5903.  
  5904.             if (FileDlg.lReturn == DID_OK) {
  5905.               PVOID pBuffer;
  5906.               pBuffer = UCMenuLoadTemplate( FileDlg.szFullFile, &ulBufLen );
  5907.               if (pBuffer) {
  5908.                 UCMenuNew( UCMData->hwndTemp, pBuffer );
  5909.                 MyFree( pBuffer );
  5910.               } /* endif */
  5911.               pszIndex = strrchr( FileDlg.szFullFile, '\\' );
  5912.               if ( pszIndex ) {
  5913.                  *( pszIndex + 1 ) = '\0';
  5914.               } /* endif */
  5915.               strncpy( UCMData->szTemplatePath, FileDlg.szFullFile, CCHMAXPATH );
  5916.             } /* endif */
  5917.  
  5918.           } break;
  5919.  
  5920.  
  5921.         case IDM_UCM_SAVEAS:
  5922.           /*┌──────────────────────────────────────────────────────────────┐
  5923.             │ Saves the template to a file                                 │
  5924.             └──────────────────────────────────────────────────────────────┘*/
  5925.           { FILEDLG FileDlg;
  5926.             UCHAR   szPath[CCHMAXPATH];
  5927.             PSZ     pszIndex;
  5928.  
  5929.             UCMData->hwndTemp = WinQueryWindow(hwnd, QW_OWNER);
  5930.             szPath[CCHMAXPATH-1] = '\0';
  5931.             strncpy( szPath, UCMData->szTemplatePath, CCHMAXPATH );
  5932.             strncat( szPath, "*.bar", CCHMAXPATH );
  5933.             memset(&FileDlg, 0, sizeof(FileDlg));
  5934.             FileDlg.cbSize = sizeof(FileDlg);
  5935.             FileDlg.fl     = FDS_SAVEAS_DIALOG | FDS_CENTER;
  5936.             strncpy( FileDlg.szFullFile, szPath, CCHMAXPATH );
  5937.             WinFileDlg(HWND_DESKTOP, hwnd, &FileDlg);
  5938.  
  5939.             if (FileDlg.lReturn == DID_OK) {
  5940.               UCMenuSaveTemplate(UCMData->hwndTemp, FileDlg.szFullFile);
  5941.               pszIndex = strrchr( FileDlg.szFullFile, '\\' );
  5942.               if ( pszIndex ) {
  5943.                  *( pszIndex + 1 ) = '\0';
  5944.               } /* endif */
  5945.               strncpy( UCMData->szTemplatePath, FileDlg.szFullFile, CCHMAXPATH );
  5946.             } /* endif */
  5947.           } break;
  5948.  
  5949.         case IDM_UCM_STYLE:
  5950.           /*┌──────────────────────────────────────────────────────────────┐
  5951.             │ Popup the ucmenu styles dialog                               │
  5952.             └──────────────────────────────────────────────────────────────┘*/
  5953.           {
  5954.             UCMData->hwndTemp = WinQueryWindow(hwnd, QW_OWNER);
  5955.  
  5956.             WinDlgBox(HWND_DESKTOP,
  5957.                       UCMData->hwndTemp,
  5958.                       UCMenuStyleDlgProc,
  5959.                       UCMData->hModUCM,
  5960.                       IDD_UCMNSTYLE,
  5961.                       (PVOID)UCMData);
  5962.             UCMData->hwndTemp = NULLHANDLE;
  5963.           }
  5964.           return (MRESULT)TRUE;
  5965.  
  5966.        default:
  5967.             {
  5968.            
  5969.                UCMData->hwndTemp = UCMData->hwndOwner;
  5970.                WinSendMsg(UCMData->hwndOwner,
  5971.                           WM_CONTROL,
  5972.                           MPFROM2SHORT( UCMData->UCMenuID, UCN_CMITEM ) ,
  5973.                           MPFROM2SHORT( SHORT1FROMMP( mp1 ), UCMData->ContextID  ) );
  5974.             }
  5975.       } // endswitch of WM_COMMAND item ID
  5976.       #endif // UCMUI
  5977.  
  5978.       break;  // end of WM_COMMAND processing
  5979.       }
  5980.  
  5981.     case WM_PAINT:
  5982.       /*┌────────────────────────────────────────────────────────┐
  5983.         │ We fill the rectangle with the UCMData->BgColor color. │
  5984.         │ We draw an inside frame                                │
  5985.         └────────────────────────────────────────────────────────┘*/
  5986.       { HPS hPS;
  5987.         RECTL rcl;
  5988.         SWP swp;
  5989.         ULONG BgColorIndex;
  5990.  
  5991.         hPS = WinBeginPaint(hwnd, (HPS)NULL, &rcl);
  5992.         BgColorIndex = UCMenuSelectColor( UCMData->BgColor, hPS );
  5993.         WinFillRect(hPS, &rcl, BgColorIndex);
  5994.  
  5995.         /*┌──────────────────────────────────────────────┐
  5996.           │ Draw lines around the menu for the 3D effect │
  5997.           └──────────────────────────────────────────────┘*/
  5998.         if (UCMData->Style & UCS_FRAMED) {
  5999.           WinQueryWindowPos( WinQueryWindow( hwnd, QW_TOP ), &swp );
  6000.           rcl.xLeft   = swp.x - MENU_FRAME_THICK;
  6001.           rcl.yBottom = swp.y - MENU_FRAME_THICK;
  6002.           rcl.xRight  = swp.x + swp.cx + MENU_FRAME_THICK;
  6003.           rcl.yTop    = swp.y + swp.cy + MENU_FRAME_THICK;
  6004.           UCMenu3DFrame( hPS, &rcl, 0 );
  6005.         }
  6006.         WinEndPaint(hPS);
  6007.       } break;
  6008.  
  6009.     case DM_DRAGOVER:
  6010.       // -------------------------------------------------------------------
  6011.       // -- We get this message when the drag icon is moved over our window.
  6012.       // -- We must verify whether or not we want to accept the drop.
  6013.       // -------------------------------------------------------------------
  6014.       return (MRESULT)(UCMenuDragOver(UCMData, hwnd,(PDRAGINFO) mp1));
  6015.  
  6016.     case DM_DROP:
  6017.       // --------------------------------------------------------
  6018.       // -- Some application has just Dropped something on us !!
  6019.       // --------------------------------------------------------
  6020.       UCMenuDrop(hwnd, (PDRAGINFO)mp1) ;
  6021.       return (MRESULT)0;
  6022.  
  6023.      default:
  6024.        return (WinDefWindowProc(hwnd, msg, mp1, mp2));
  6025.   } // endswitch
  6026.  
  6027.   return (MRESULT)FALSE;
  6028. }
  6029.  
  6030. //----------------------------------------------------------------------------
  6031. // SubmenuWndProc
  6032. //----------------------------------------------------------------------------
  6033. // :pfunction res=&IDF_SUBMWNDPROC. name='SubmenuWndProc' text='Submenu window procedure'.
  6034. // Window procedure of the submenus
  6035. // :syntax name='SubmenuWndProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  6036. // :fparams.
  6037. // :fparam name='hwnd' type='HWND' io='input' .
  6038. // Submenu window handle
  6039. // :fparam name='msg' type='ULONG' io='input' .
  6040. // Message
  6041. // :fparam name='mp1' type='MPARAM' io='input'.
  6042. // First parameter
  6043. // :fparam name='mp2' type='MPARAM' io='input'.
  6044. // Second parameter
  6045. // :freturns.
  6046. // :fparam name='mresult' type='MRESULT' io='return'.
  6047. // Return code of a PM message.
  6048. // :efparams.
  6049. // :remarks.
  6050. // We process the WM_ADJUSTWINDOWPOS message to position the window on the right
  6051. // of the nebu item instead under it for vertical ucmenus
  6052. // :epfunction.
  6053. //----------------------------------------------------------------------------
  6054. MRESULT EXPENTRY SubmenuWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  6055. {
  6056.    PUCMDATA  UCMData = (PUCMDATA)WinQueryWindowPtr(hwnd, 0L);
  6057.  
  6058.    switch (msg) {
  6059.  
  6060. //  case WM_BUTTON2DOWN:
  6061. //  case WM_BUTTON1DOWN: {
  6062. //        /* On any button down, release capture and disable the bubble  */
  6063. //        /* help window.  It will be re-enabled when the button is      */
  6064. //        /* released (or drag/drop done, in that case).                 */
  6065. //
  6066. //        if (UCMData->Style & UCS_BUBBLEHELP)
  6067. //          WinSendMsg(UCMData->hwndBubble, MSG_DISABLE_BUBBLE, 0L, 0L);
  6068. //
  6069. //        if (UCMData->HoverCapture) {
  6070. //          WinSetCapture(HWND_DESKTOP, NULLHANDLE);
  6071. //          UCMData->HoverCapture = FALSE;
  6072. //        }
  6073. //        
  6074. //        if (msg == WM_BUTTON2DOWN)  // Drag/drop does not work if default proc gets this
  6075. //          break;                    // ??? should use WinQuerySysValue(...SV_BEGINDRAG...)
  6076. //        return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  6077. //        }
  6078. //
  6079. //
  6080. //  case WM_BUTTON2UP:
  6081. //  case WM_BUTTON1UP: {
  6082. //        MRESULT rc;
  6083. //
  6084. //        /* First let normal window proc process the UP message */
  6085. //        /* It will POST a WM_COMMAND to our UCMenu window if   */
  6086. //        /* the mouse is still on the menu item.                */
  6087. //        rc = UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); 
  6088. //
  6089. //        /* Simulate a mouse-move so that we will recapture the */
  6090. //        /* mouse if needed.  Set a flag for the WM_MOUSEMOVE   */
  6091. //        /* code to recognize this is a fake movement.          */
  6092. //
  6093. //        UCMData->HoverMsg = msg;
  6094. //        if (UCMData->Style & UCS_BUBBLEHELP)
  6095. //          WinSendMsg(UCMData->hwndBubble, MSG_ENABLE_BUBBLE, 0L, 0L);
  6096. //
  6097. //
  6098. //        /* NOTE: This message must be POSTED so it arrives         */
  6099. //        /* after WM_COMMAND has been received and UCN_ITEMSELECTED */
  6100. //        /* processed by the application.  Otherwise the app could  */
  6101. //        /* invoke a dialog in response to UCN_ITEMSELECTED and     */
  6102. //        /* cause us to lose mouse capture tracking.                */
  6103. //
  6104. //        WinPostMsg(hwnd, WM_MOUSEMOVE, mp1, mp2);
  6105. //        return rc;
  6106. //        }
  6107. //     
  6108. //  case WM_MOUSEMOVE:
  6109. //     {
  6110. //        USHORT   usId;      /* ID of menu item under mouse */
  6111. //        POINTL   ptl;       /* Mouse position in the window */
  6112. //        HWND hwndUCM   = WinQueryWindow( UCMData->hwndMenu, QW_OWNER );
  6113. //        HWND hwndOwner = WinQueryWindow( hwndUCM, QW_OWNER );
  6114. //        HWND HwndAt;        /* Window at mouse position */
  6115. //        BOOL Inside    = TRUE;
  6116. //        BOOL ButtonDown= FALSE;
  6117. //
  6118. //        /* If our app is not the active window, just pass it on */
  6119. //        if (!(UCMData->Active))
  6120. //          return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 );
  6121. //
  6122. //        /* See if any mouse button is pressed (and this is not from a BUTTONUP msg above). */
  6123. //        if ((WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & 0x8000) && (UCMData->HoverMsg != WM_BUTTON1UP))
  6124. //          ButtonDown = TRUE;
  6125. //        if ((WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000) && (UCMData->HoverMsg != WM_BUTTON2UP))
  6126. //          ButtonDown = TRUE;
  6127. //        UCMData->HoverMsg = WM_NULL;
  6128. //
  6129. //        ptl.x = (ULONG) SHORT1FROMMP( mp1 );
  6130. //        ptl.y = (ULONG) SHORT2FROMMP( mp1 );
  6131. //
  6132. //        /* Note we must test entire desktop window hierarchy for PM */
  6133. //        /* to tell us if the point is over a window which obscures  */
  6134. //        /* our own.  If we search only our own window hierarchy, we */
  6135. //        /* will detect movements whenever the pointer is inside our */
  6136. //        /* window rectangle, even if our window is covered by       */
  6137. //        /* some other application.  Searching the desktop hierarchy */
  6138. //        /* is bad for performance, but PM gives us no other way to  */
  6139. //        /* detect (for sure) when the mouse leaves our menu window. */
  6140. //
  6141. //        WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1);
  6142. //        HwndAt = WinWindowFromPoint(HWND_DESKTOP, &ptl, TRUE);
  6143. //        if (HwndAt != hwnd)
  6144. //          Inside = FALSE;
  6145. //
  6146. //        /* Restore point to my coordinate system */
  6147. //        ptl.x = (ULONG) SHORT1FROMMP( mp1 );
  6148. //        ptl.y = (ULONG) SHORT2FROMMP( mp1 );
  6149. //
  6150. //        /* If mouse is over another window (even if within the menu */
  6151. //        /* window rectangle), we don't use it.  Coord mapping       */
  6152. //        /* routine will be fooled by overlapping windows.           */
  6153. //
  6154. //        if (!Inside)
  6155. //          usId = 0;
  6156. //        else
  6157. //          usId  = UCMenuIdFromCoord(hwnd, &ptl ); // Where is it?
  6158. //
  6159. //        if (usId != UCMData->HoverID) {               // Tell owner of any change
  6160. //          if (UCMData->Style & UCS_PROMPTING)         // ...if they want to know.
  6161. //            WinSendMsg( hwndOwner, WM_CONTROL,
  6162. //                        MPFROM2SHORT( WinQueryWindowUShort( hwndUCM, QWS_ID ), UCN_MOUSEMOVE ),
  6163. //                        MPFROMSHORT( usId ) );
  6164. //          if (UCMData->Style & UCS_BUBBLEHELP) {      // ...if bubble needs to know
  6165. //            BOOL Deactivate = TRUE;                   // Bubble should be deactivated
  6166. //            if ((HwndAt == UCMData->hwndMenu) ||              // ... unless ptr
  6167. //    //          (HwndAt == UCMData->hwndBubble) ||
  6168. //    //          (HwndAt == WinQueryWindow(UCMData->hwndMenu, QW_PARENT)) ||  // hide window
  6169. //                (WinQueryWindow(HwndAt,QW_OWNER)==UCMData->hwndMenu))  // is over any TB menu
  6170. //                Deactivate = FALSE;
  6171. //            WinSendMsg(UCMData->hwndBubble,           
  6172. //                        MSG_ITEMCHANGE, MPFROM2SHORT(usId, Deactivate), MPFROMHWND(hwnd));
  6173. //          }
  6174. //        }
  6175. //        UCMData->HoverID = usId;                      // Save for next time
  6176. //
  6177. //        /* We (UCMenus) will capture the mouse if:               */
  6178. //        /*  - The mouse is inside the menu window                */
  6179. //        /*  - We don't already have it captured                  */
  6180. //        /*  - No buttons are pressed                             */
  6181. //
  6182. //        if ((Inside) && (!UCMData->HoverCapture) && (!ButtonDown)) {
  6183. //           WinSetCapture(HWND_DESKTOP, hwnd);
  6184. //           UCMData->HoverCapture = TRUE;
  6185. //        }
  6186. //
  6187. //        /* We release capture if:                                */
  6188. //        /*  - Mouse is outside the menu window                   */
  6189. //        /*  - No buttons down                                    */
  6190. //        /*  - We have capture set                                */
  6191. //
  6192. //        if ((!Inside) && (!ButtonDown) && (UCMData->HoverCapture)) {
  6193. //           WinSetCapture(HWND_DESKTOP, NULLHANDLE);    // Stop capture
  6194. //           UCMData->HoverCapture = FALSE;              // No longer captured
  6195. //           UCMData->HoverID = 0;
  6196. //        }
  6197. //
  6198. //        return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  6199. //     }
  6200.  
  6201.  
  6202.     case MM_INSERTITEM:
  6203.     case MM_SETITEM:
  6204.        {
  6205.           PMENUITEM pMi = 0;
  6206.           USHORT    NewID, NotifyMsg;
  6207.           MRESULT   rc;
  6208.  
  6209.           switch (msg) {
  6210.           case MM_INSERTITEM:
  6211.              pMi = (PMENUITEM)mp1;
  6212.              // Check if the id is already used
  6213.              NewID = UCMenuGetNewID( UCMData->hwndMenu, pMi->id, UCMData );
  6214.              if ( NewID != pMi->id) {
  6215.                 pMi->id = NewID;
  6216.                 if ( pMi->hItem ){
  6217.                    ITEM( pMi, usId ) = NewID;
  6218.                 } // endif
  6219.              } /* endif */
  6220.              break;
  6221.           case MM_SETITEM:
  6222.              pMi = (PMENUITEM)mp2;
  6223.              // The item was already in the menu, so its
  6224.              // id should be correct
  6225.             break;
  6226.           } // endswitch
  6227.  
  6228.           //(MAM) Don't allow BREAK on any menu item.
  6229.           pMi->afStyle = pMi->afStyle & ~MIS_BREAK;
  6230.  
  6231.           if ( pMi && pMi->hItem ){
  6232.              // Set the id also in ucmitem
  6233.              // --
  6234.              ITEM( pMi, usId ) = pMi->id;
  6235.              // Load the btimap
  6236.              // --
  6237.              UCMenuLoadItemBmp(pMi, UCMData );
  6238.           } // endif
  6239.  
  6240.           rc = UCMData->OldSubMenuProc(hwnd, msg, mp1, mp2);
  6241.  
  6242.           // if an item was added, notify application (AFTER the insert is done)
  6243.           if (msg==MM_INSERTITEM)
  6244.             NotifyMsg = UCN_ADDEDITEM;
  6245.           else
  6246.             NotifyMsg = UCN_CHANGEDITEM;
  6247.           WinSendMsg( UCMData->hwndOwner,
  6248.                   WM_CONTROL,
  6249.                   MPFROM2SHORT( UCMData->UCMenuID, NotifyMsg ),
  6250.                   MPFROMSHORT( pMi->id ) );
  6251.  
  6252.           return rc;
  6253.        }
  6254.  
  6255.     //(MAM) Added DELETE processing here for submenus.  Any MM_DELETEITEM type
  6256.     // request received by the main menu for a submenu item will be done here.
  6257.     case MM_DELETEITEM:
  6258.     case MM_REMOVEITEM:
  6259.     case MM_SETITEMHANDLE: {
  6260.         MRESULT rc;
  6261.         USHORT  NotifyMsg;
  6262.  
  6263.         if ( msg == MM_DELETEITEM ){
  6264.            MENUITEM mi;
  6265.  
  6266.            if ( WinSendMsg(UCMData->hwndMenu, MM_QUERYITEM, mp1, MPFROMP(&mi)) &&
  6267.                 mi.hItem ){
  6268.               if ( ITEM( &mi, pszBmp ) ){
  6269.                 MyFree( ITEM( &mi, pszBmp ) );
  6270.               }
  6271.               if ( ITEM( &mi, pszText ) ){
  6272.                 MyFree( ITEM( &mi, pszText ) );
  6273.               }
  6274.               if ( ITEM( &mi, pszAction ) ){
  6275.                 MyFree( ITEM( &mi, pszAction ) );
  6276.               }
  6277.               if ( ITEM( &mi, pszData ) ){
  6278.                 MyFree( ITEM( &mi, pszData ) );
  6279.               }
  6280.               if ( ITEM( &mi, pszParameters ) ){
  6281.                 MyFree( ITEM( &mi, pszParameters ) );
  6282.               }
  6283.               if ( ITEM( &mi, hBmp ) ){
  6284.                 GpiDeleteBitmap( ITEM( &mi, hBmp ) );
  6285.               }
  6286.               MyFree( (PVOID)mi.hItem );
  6287.               if ( mi.hwndSubMenu ){
  6288.                  UCMenuFreeMenuData( mi.hwndSubMenu );
  6289.               } // endif
  6290.            } // endif
  6291.  
  6292.         } // endif
  6293.  
  6294.         rc = UCMData->OldSubMenuProc(hwnd, msg, mp1, mp2);
  6295.      // if ((USHORT)WinSendMsg(hwnd, MM_QUERYITEMCOUNT, MPVOID, MPVOID) == 0) {
  6296.      //   /* Just deleted last item of a submenu.  Remove submenu attribute */
  6297.      //   /* of the parent menu item.                                       */
  6298.      //   //...not implemented yet: define a new mssage, UCMENU_QUERYSUBMENUPARENT
  6299.      //   //...which returns the item ID of the parent item of the
  6300.      //   //...submenu.  Implement the message by enumerating all the parent items
  6301.      //   //...and look for our window handle in the MENUITEM.hwndSubMenu field.
  6302.      //   //...When found, remove MIA_SUBMENU attribute, set hwndSubMenu to NULL,
  6303.      //   //...and destroy this submenu window.
  6304.      // }
  6305.  
  6306.         if ((msg==MM_DELETEITEM) || (msg==MM_REMOVEITEM))
  6307.           NotifyMsg = UCN_DELETEDITEM;
  6308.         else
  6309.           NotifyMsg = UCN_CHANGEDITEM;
  6310.         WinSendMsg( UCMData->hwndOwner,
  6311.                    WM_CONTROL,
  6312.                    MPFROM2SHORT( UCMData->UCMenuID, NotifyMsg ),
  6313.                    MPFROMSHORT( SHORT1FROMMP( mp1 ) ) );
  6314.  
  6315.         return rc;
  6316.         }
  6317.  
  6318.      case WM_CONTEXTMENU:
  6319.         {
  6320.          /*┌──────────────────────────────────────────────────────────────┐
  6321.            │ Show the pop-up menu                                         │
  6322.            └──────────────────────────────────────────────────────────────┘*/
  6323.  
  6324.            UCMenuContextMenu(UCMData->hwndUCM,
  6325.                              hwnd,
  6326.                              (ULONG)mp1);
  6327.            return (MRESULT) TRUE;
  6328.         }
  6329.      case WM_SYSCOLORCHANGE:
  6330.         // Don't let original menu window proc process this.
  6331.         return((MRESULT)0);
  6332.  
  6333.      case WM_PRESPARAMCHANGED:
  6334.           {
  6335.           MRESULT rc;
  6336.              UCMenuPresParamChanged( UCMData, hwnd, mp1 );
  6337.              rc = UCMData->OldSubMenuProc(hwnd, msg, mp1, mp2);
  6338.              /* Need to dismiss submenu or font changes have odd effects */
  6339.              WinSendMsg(hwnd, MM_ENDMENUMODE, MPFROMSHORT(TRUE), MPVOID);
  6340.              return rc;
  6341.           }
  6342.  
  6343.      case WM_ADJUSTWINDOWPOS:
  6344.        { PSWP pswp;
  6345.          ULONG Style       = WinQueryWindowULong(UCMData->hwndUCM, QWL_STYLE);
  6346.  
  6347.          pswp = (PSWP)mp1;
  6348.  
  6349.          if ( UCMData && ( pswp->fl & SWP_MOVE ) && !WinIsWindowShowing( hwnd ) ) {
  6350.            RECTL rect;
  6351.            WinSendMsg(UCMData->hwndMenu,
  6352.                       MM_QUERYITEMRECT,
  6353.                       MPFROM2SHORT(UCMData->usItem,TRUE),
  6354.                       MPFROMP(&rect));
  6355.            switch (Style & 0x07) {
  6356.              case CMS_VERT:
  6357.                pswp->y += (rect.yTop   - rect.yBottom);
  6358.                pswp->x += (rect.xRight - rect.xLeft);
  6359.                break;
  6360.              case CMS_MATRIX:
  6361.                pswp->x += (rect.xRight - rect.xLeft);
  6362.                break;
  6363.            } // endswitch
  6364.          } // endif
  6365.  
  6366.          return (MRESULT)(UCMData->OldSubMenuProc(hwnd, msg, mp1, mp2));
  6367.        }
  6368.  
  6369.      default:
  6370.        {
  6371.           return (UCMenuDrgDrpMsg(UCMData, hwnd, msg, mp1, mp2, UCMData->OldSubMenuProc));
  6372.        }
  6373.    } // endswitch
  6374.    return 0;
  6375. }
  6376.  
  6377. //----------------------------------------------------------------------------
  6378. void _Optlink UCMenuCreateBubbleWindow(HWND UCMenuHwnd, UCMDATA *UCMData)
  6379. //----------------------------------------------------------------------------
  6380. // Create the bubble-help window.
  6381. //----------------------------------------------------------------------------
  6382. {
  6383.   /* Register class with room for 1 pointer */
  6384.   WinRegisterClass( (HAB)NULLHANDLE, BUBBLECLASS, (PFNWP)BubbleWndProc, 0L, (ULONG)sizeof(PVOID) );
  6385.  
  6386.   /* Create the bubble window  */
  6387.   // CS_SAVEBITS makes the bubble disappear faster, but can cause incorrect
  6388.   // painting of windows under it if they change while the bubble is up (esp menus)
  6389.   UCMData->hwndBubble = WinCreateWindow(HWND_DESKTOP,
  6390.                                         BUBBLECLASS,    // Bubble class window
  6391.                                         "",
  6392.                                   //    WS_SAVEBITS,    // Window style
  6393.                                         0L,             // Window style
  6394.                                         0,0,0,0,        // Size set by window proc as needed
  6395.                                         UCMenuHwnd,     // Owner
  6396.                                         HWND_TOP,
  6397.                                         0,              // ID is not used
  6398.                                         UCMData,        // Pass ptr to global data
  6399.                                         NULL);          // No pres params
  6400.  
  6401.    if (UCMData->pszFontNameSize[0] != '\0')
  6402.      WinSetPresParam( UCMData->hwndBubble, PP_FONTNAMESIZE,  // Make it same font as menu
  6403.                       strlen(UCMData->pszFontNameSize) + 1,
  6404.                       UCMData->pszFontNameSize);
  6405.  
  6406. } 
  6407.  
  6408. //----------------------------------------------------------------------------
  6409. MRESULT EXPENTRY BubbleWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  6410. //----------------------------------------------------------------------------
  6411. // Bubble-help window procedure.
  6412. //----------------------------------------------------------------------------
  6413. {
  6414. #define BUBBLE_MARGIN_TOP        3
  6415. #define BUBBLE_MARGIN_BOT        3
  6416. #define BUBBLE_MARGIN_LEFT       3
  6417. #define BUBBLE_MARGIN_RIGHT      3
  6418. typedef struct { /*--- Bubble help window instance data ---*/
  6419.    UCMDATA      *UCMData            ;             // Ptr to UCMenu instance data
  6420.    char         *Text               ;             // Current bubble text
  6421.    USHORT       CurrID              ;             // Menu ID of current item
  6422.    HWND         CurrMenu            ;             // Handle of menu or submenu
  6423.    BOOL         Disabled            ;             // Bubble is currently disabled
  6424.    BOOL         Active              ;             // Bubble window is currently active
  6425.    POINTL       OffMenuPos          ;             // Point at which pointer left the toolbar
  6426.    BOOL         OffMenuActive       ;             // Was bubble active when pointer left?
  6427.    POINTL       StemPoint           ;             // X,Y coordinate of tip of stem (desktop)
  6428.    ULONG        TextHeight,TextWidth;             // Dimensions of text including margin
  6429.    ULONG        StemHeight,StemWidth;             // Dimensions of stem (not rectangular)
  6430.    LONG         XPos, YPos          ;             // X,Y pos of bbl window (desktop)
  6431.    BOOL         OnTop               ;             // Bubble is above menu item
  6432.    ULONG        DismissTimer        ;             // Handle of autodismiss timer
  6433. } BBLDATA, *PBBLDATA;
  6434.  
  6435. // "Active" means delay has been satisified already and bubble should
  6436. // update as pointer moves from item to item.  It does NOT mean the bubble
  6437. // is visible on the screen (e.g. if pointer is over a SPACER item, the
  6438. // bubble is still active, but not displayed since there is no help text).
  6439. //
  6440. // "Disabled" means the bubble window is not to be displayed (because some
  6441. // other interaction is in progress on the toolbar, such as a context menu).
  6442. // When bubble is disabled it is by definition also in-Active.  When re-enabled
  6443. // it will become active again after the normal delay period.
  6444.  
  6445. BBLDATA *BblData;   /* Ptr to bubble-instance data.  Not valid until after WM_CREATE */
  6446.  
  6447.   BblData = (BBLDATA *)WinQueryWindowPtr(hwnd, 0L);
  6448.  
  6449.   switch (msg) {
  6450.     case WM_CREATE:
  6451.       /* Create and initialize bubble-help instance data */
  6452.       BblData = MyMalloc(sizeof(BBLDATA));
  6453.       memset(BblData, 0x00, sizeof(BBLDATA));
  6454.  
  6455.       BblData->UCMData = (UCMDATA *)mp1;  /* MP1 is ptr to UCM instance data */
  6456.       WinSetWindowPtr(hwnd, 0L, BblData);
  6457.       return 0;
  6458.  
  6459.     case WM_DESTROY:
  6460.       WinStopTimer((HAB)NULLHANDLE, hwnd, TIMER_BUBBLE); // Cancel any pending update
  6461.       /* Free storage we have before quiting */
  6462.       if (BblData->Text != NULL)
  6463.         MyFree(BblData->Text);
  6464.       MyFree(BblData);
  6465.       break;
  6466.  
  6467.     case MSG_DISABLE_BUBBLE:
  6468.       /* Disable bubble until MSG_ENABLE_BUBBLE occures. */
  6469.       BblData->Disabled = TRUE;
  6470.       BblData->Active = FALSE;
  6471.       WinStopTimer((HAB)NULLHANDLE, hwnd, TIMER_BUBBLE); // Cancel any pending update
  6472.       WinSetWindowPos(hwnd, HWND_TOP, 0,0,0,0, SWP_HIDE);
  6473.       return 0;
  6474.  
  6475.     case MSG_ENABLE_BUBBLE: {
  6476.       USHORT TempID;
  6477.  
  6478.       BblData->Disabled = FALSE;
  6479.       /* Send fake itemchange message to start delay period */
  6480.       TempID = BblData->CurrID;
  6481.       BblData->CurrID = 0;  // Force update
  6482.       WinSendMsg(hwnd, MSG_ITEMCHANGE, MPFROM2SHORT(TempID,FALSE), MPFROMHWND(BblData->CurrMenu));
  6483.       return 0;
  6484.       }
  6485.  
  6486.     case MSG_ITEMCHANGE: {
  6487.       /* mp1 = (SHORT) new item ID               */
  6488.       /*       (BOOL) deactivate if ID=0 (T/F)   */
  6489.       /* mp2 = (HWND) menu window                */
  6490.       POINTL PtrPos;
  6491.       HWND   NewHwnd;
  6492.  
  6493.       /* Pointer has moved on a menu item.  If item is different */
  6494.       /* than last time, schedule bubble window update.          */
  6495.  
  6496.       if (SHORT1FROMMP(mp1) == BblData->CurrID)
  6497.         return 0;  // Do nothing if no change
  6498.  
  6499.       BblData->CurrID = SHORT1FROMMP(mp1);
  6500.       BblData->CurrMenu = HWNDFROMMP(mp2);
  6501.  
  6502.       /* If item ID is zero, pointer moved off toolbar.  If     */
  6503.       /* caller says to deactivate, hide bubble and delay before*/
  6504.       /* showing again.  Otherwise keep current active status.  */
  6505.  
  6506.       if (BblData->CurrID == 0) {
  6507.         WinSetWindowPos(hwnd, HWND_TOP, 0,0,0,0, SWP_HIDE);
  6508.         WinStopTimer((HAB)NULLHANDLE, hwnd, TIMER_BUBBLE); // Cancel any pending update
  6509.         if ((BOOL)SHORT2FROMMP(mp1))  // Caller says deactivate
  6510.           BblData->Active = FALSE;
  6511.         return 0;
  6512.       }
  6513.  
  6514.       /* If we are disabled, no need to schedule update */
  6515.       if (BblData->Disabled)
  6516.         return 0;
  6517.  
  6518.       /* If bubble is already active,  update immediately w/new data */
  6519.       /* otherwise delay before showing it.  If delay time is set to */
  6520.       /* less than minimum,  fake an immediate timer event (e.g. no  */
  6521.       /* delay at all).                                              */
  6522.  
  6523.       if (BblData->Active)
  6524.         WinSendMsg(hwnd, MSG_UPDATE_BUBBLE, 0L, 0L);
  6525.       else {
  6526.         if (BblData->UCMData->BubbleDelay < MIN_BUBBLE_DELAY)
  6527.           WinSendMsg(hwnd, WM_TIMER, MPFROMSHORT(TIMER_BUBBLE_FAKE), 0L);
  6528.         else
  6529.           WinStartTimer((HAB)NULLHANDLE, hwnd, TIMER_BUBBLE, BblData->UCMData->BubbleDelay);
  6530.       }
  6531.  
  6532.       return 0;
  6533.       }
  6534.  
  6535.     case WM_TIMER:
  6536.       switch (SHORT1FROMMP(mp1)) {
  6537.         case TIMER_BUBBLE: {
  6538.           POINTL PtrPos;
  6539.           /* Real PM timer event occured.  Stop timer. */
  6540.           WinStopTimer((HAB)NULLHANDLE, hwnd, TIMER_BUBBLE);
  6541.           /* If pointer has moved off window (but window proc has not noticed yet) */
  6542.           /* then do not activate the bubble.                                      */
  6543.           WinQueryPointerPos(HWND_DESKTOP, &PtrPos);
  6544.           if (WinWindowFromPoint(HWND_DESKTOP, &PtrPos, TRUE) != BblData->CurrMenu)
  6545.             return 0;
  6546.           /* else fall through next case... */
  6547.           }
  6548.         case TIMER_BUBBLE_FAKE:
  6549.           /* Display bubble help now */
  6550.           BblData->Active = TRUE;  // Bubble is now active
  6551.           WinSendMsg(hwnd, MSG_UPDATE_BUBBLE, 0L, 0L);
  6552.           return 0;
  6553.         case TIMER_BBLAUTODISMISS:
  6554.           /* Time to remove the bubble help */
  6555.           WinSendMsg(hwnd, MSG_ITEMCHANGE, MPFROM2SHORT(0, TRUE), MPFROMHWND(BblData->CurrMenu));
  6556.           WinStopTimer((HAB)0, hwnd, BblData->DismissTimer);
  6557.           return 0;
  6558.       }
  6559.       break;
  6560.  
  6561.  
  6562.     case MSG_UPDATE_BUBBLE: {
  6563.       /* Update the bubble window with current data.  If window */
  6564.       /* is not disabled, show it.                              */
  6565.       HPS Hps;
  6566.       RECTL   TextBox;
  6567.       RECTL   itemRect;
  6568.       POINTL  BubblePt;
  6569.       QBUBBLEDATA QueryData;
  6570.       MENUITEM Item;
  6571.  
  6572.       if (BblData->CurrID == 0) { // should not happen
  6573.         return 0;
  6574.       }
  6575.  
  6576.       /* Calculate window size needed */
  6577.  
  6578.       if (BblData->Text != NULL) // free any previous data
  6579.         MyFree(BblData->Text);
  6580.  
  6581.       QueryData.BubbleText = NULL;   // Setup for call to application
  6582.       QueryData.MenuItem   = &Item;
  6583.       if ((BOOL)WinSendMsg(BblData->CurrMenu, MM_QUERYITEM, MPFROM2SHORT(BblData->CurrID,TRUE), MPFROMP(&Item))) {
  6584.         WinSendMsg(BblData->UCMData->hwndOwner,
  6585.                    WM_CONTROL,
  6586.                    MPFROM2SHORT(BblData->UCMData->UCMenuID, UCN_QRYBUBBLEHELP),
  6587.                    MPFROMP(&QueryData));
  6588.       }
  6589.  
  6590.       /* If app gave us a string to use, make a copy and then free application's string */
  6591.       if (QueryData.BubbleText != NULL) {
  6592.         BblData->Text = MyStrdup(QueryData.BubbleText);
  6593.         MyFree(QueryData.BubbleText);
  6594.       }
  6595.       else
  6596.         BblData->Text = NULL;
  6597.  
  6598.       /* If there is no text, just hide the bubble window (it will still be 'active') */
  6599.       if ((BblData->Text == NULL) || (BblData->Text[0] == '\0')) {
  6600.         WinSetWindowPos(hwnd, HWND_TOP, 0,0,0,0, SWP_HIDE);
  6601.         return 0;
  6602.       }
  6603.  
  6604.       /* Calculate window size needed to contain text */
  6605.  
  6606.       Hps = WinGetPS(hwnd);    //@P4m
  6607.       TextBox.xLeft = 0;
  6608.       TextBox.yBottom = 0;
  6609.       TextBox.xRight = MAX_INT;
  6610.       TextBox.yTop = MAX_INT;
  6611.       WinDrawText(Hps, -1, BblData->Text, &TextBox, 0L, 0L, DT_QUERYEXTENT|DT_LEFT|DT_VCENTER);
  6612.       WinReleasePS(Hps);       //@P4a
  6613.  
  6614.       BblData->TextWidth = BUBBLE_MARGIN_LEFT+BUBBLE_MARGIN_RIGHT+(TextBox.xRight - TextBox.xLeft);
  6615.       BblData->TextHeight= BUBBLE_MARGIN_TOP +BUBBLE_MARGIN_BOT  +(TextBox.yTop - TextBox.yBottom);
  6616.       BblData->StemHeight= BblData->TextHeight;
  6617.       BblData->StemWidth = BblData->StemHeight/2;
  6618.       BblData->OnTop     = TRUE;
  6619.  
  6620.       /* Minimum bubble width is wide enough for two rounded corners, a stem base     */
  6621.       /* and some extra.                                                              */
  6622.       BblData->TextWidth = max(BblData->TextWidth, BblData->TextHeight + BblData->TextHeight/2);
  6623.  
  6624.       /* Get position of the item in the menu window */
  6625.       if (!(BOOL)WinSendMsg(BblData->CurrMenu, MM_QUERYITEMRECT, MPFROM2SHORT(BblData->CurrID, TRUE), MPFROMP(&itemRect))) {
  6626.       }
  6627.  
  6628.       /* Map to desktop coordinates.  */
  6629.  
  6630.       BblData->StemPoint.x = itemRect.xLeft + ((itemRect.xRight-itemRect.xLeft)/2);
  6631.       BblData->StemPoint.y = itemRect.yTop;
  6632.       WinMapWindowPoints(BblData->CurrMenu, HWND_DESKTOP, &(BblData->StemPoint), 1L);
  6633.  
  6634.       /* If bubble is over top of screen, flip to underside of menu item */
  6635.       if (BblData->StemPoint.y + BblData->TextHeight + BblData->StemHeight > WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN)) {
  6636.         BblData->OnTop = FALSE;   // Put bubble under the menu item
  6637.         BblData->StemPoint.y = BblData->StemPoint.y - (itemRect.yTop-itemRect.yBottom);
  6638.       }
  6639.  
  6640.       /* If tip of stem is off the screen (x-dimension), bring it back */
  6641.       BblData->StemPoint.x = min(max(0L, (LONG)BblData->StemPoint.x), WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN));
  6642.  
  6643.       /* Try to position bubble window 1/4 MaxHeight to the left  of the stem tip. */
  6644.       /* This gives a nice look to the stem and bubble.                            */
  6645.  
  6646.       BblData->XPos = min(max(0L,(LONG)(BblData->StemPoint.x-(LONG)(BblData->TextHeight/4))), WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN)-BblData->TextWidth);
  6647.       if (BblData->OnTop)
  6648.         BblData->YPos = BblData->StemPoint.y;
  6649.       else
  6650.         BblData->YPos = BblData->StemPoint.y - BblData->TextHeight - BblData->StemHeight;
  6651.  
  6652.       /* Size/position the bubble window.  Hide it so background will be */
  6653.       /* restored (since we don't repaint our entire window area).       */
  6654.       WinSetWindowPos(hwnd, HWND_TOP, BblData->XPos,
  6655.                                       BblData->YPos,
  6656.                                       BblData->TextWidth,
  6657.                                       BblData->TextHeight+BblData->StemHeight,
  6658.                                       SWP_MOVE|SWP_SIZE|SWP_HIDE);
  6659.  
  6660.       /* Map stem point to bubble window coordinates after move/size */
  6661.       WinMapWindowPoints(HWND_DESKTOP, hwnd, &(BblData->StemPoint), 1L);
  6662.  
  6663.       /* If we are not disabled, show window and force repaint */
  6664.       if (!BblData->Disabled) {
  6665.         // We must wait for all WM_PAINT msgs to be processed by other windows run off our
  6666.         // message queue, or they may not be updated before our semi-transparent window
  6667.         // is displayed, resulting in those windows not appearing to have been updated.
  6668.         {QMSG QMsg;
  6669.         while(WinPeekMsg((HAB)0, &QMsg, NULLHANDLE, WM_PAINT, WM_PAINT, PM_REMOVE))
  6670.           WinDispatchMsg((HAB)0, &QMsg);
  6671.         }
  6672.         WinSetWindowPos(hwnd, HWND_TOP, 0,0,0,0, SWP_SHOW|SWP_ZORDER);
  6673.         WinInvalidateRect(hwnd, NULL, FALSE);
  6674.         /* Start timer to autodismiss the bubble, min timeout is 1 second */
  6675.         BblData->DismissTimer = WinStartTimer((HAB)0, hwnd, TIMER_BBLAUTODISMISS, max(1000L,BblData->UCMData->BubbleRead));
  6676.       }
  6677.       return 0;
  6678.       }
  6679.  
  6680.     case WM_PAINT:
  6681.       {
  6682.       HPS    Hps;                       /* Presentation Space handle    */
  6683.       RECTL  Rect;                      /* Rectangle coordinates        */
  6684.       POINTL Pt;                        /* String screen coordinates    */
  6685.       POINTL StemPts[3];                /* Points in stem polygon       */
  6686.       POLYGON PolyInfo;                 /* Polygon information          */
  6687.       SWP    SizePos;                   /* Size/pos of the window       */
  6688.       ULONG  Rounding;                  /* Corner rounding factor       */
  6689.       LONG   SlantOffset;               /* Offset of tip for slant angle*/
  6690.       LONG   SlantDir;                  /* +/-1 slant direction         */
  6691.  
  6692.       Hps = WinBeginPaint(hwnd, 0L, &Rect);  /* Get PS to draw */
  6693.       WinQueryWindowPos(hwnd, &SizePos);     /* Get window size*/
  6694.  
  6695.       /* Draw bubble rectangle with rounded corners */
  6696.  
  6697.       Pt.x = 0;                      // Lower left corner
  6698.       if (BblData->OnTop)
  6699.         Pt.y = BblData->StemHeight;
  6700.       else
  6701.         Pt.y = 0;
  6702.       GpiMove(Hps, &Pt);
  6703.       Pt.x = BblData->TextWidth-1;   // Upper right corner
  6704.       Pt.y = Pt.y + BblData->TextHeight-1;
  6705.  
  6706.       Rounding = BblData->TextHeight/2;
  6707.       GpiSetColor(Hps, CLR_YELLOW);
  6708.       GpiBox(Hps, DRO_FILL,    &Pt, Rounding, Rounding); // Draw filled rect
  6709.       GpiSetColor(Hps, CLR_BLACK);
  6710.       GpiBox(Hps, DRO_OUTLINE, &Pt, Rounding, Rounding); // Draw outline
  6711.  
  6712.       /* Change slant angle if tip is on right side of bubble */
  6713.       SlantOffset = BblData->TextHeight / 2;
  6714.       SlantDir    = 1;
  6715.       if (BblData->StemPoint.x > BblData->TextWidth/2)
  6716.         SlantDir = -1;
  6717.  
  6718.       /* Calculate X position of stem verticies */
  6719.       /* [0] = left base corner                 */
  6720.       /* [1] = tip                              */
  6721.       /* [2] = right base corner                */
  6722.       
  6723.       StemPts[1].x = BblData->StemPoint.x;        // Tip is fixed position
  6724.       StemPts[0].x = StemPts[1].x + (SlantOffset * SlantDir);
  6725.       StemPts[2].x = StemPts[0].x + (BblData->StemWidth * SlantDir);
  6726.  
  6727.       /* Set Y position of stem verticies */
  6728.       StemPts[1].y = BblData->StemPoint.y;        // Tip position is fixed
  6729.       if (BblData->OnTop)                         // Base above or below tip
  6730.         StemPts[0].y = BblData->StemHeight;
  6731.       else
  6732.         StemPts[0].y = BblData->TextHeight-1;
  6733.       StemPts[2].y = StemPts[0].y;
  6734.  
  6735.       /* Draw polygon starting at first stem point */
  6736.       GpiMove(Hps, &(StemPts[0]));
  6737.       PolyInfo.aPointl = StemPts;    // Describe polygon
  6738.       PolyInfo.ulPoints = 3;
  6739.       GpiSetColor(Hps, CLR_YELLOW);
  6740.       GpiPolygons(Hps, 1L, &PolyInfo, 0L, 0L);  // Draw filled stem
  6741.       GpiSetColor(Hps, CLR_BLACK);
  6742.       GpiMove(Hps, &(StemPts[0]));              // Draw outline
  6743.       GpiLine(Hps, &(StemPts[1]));
  6744.       GpiLine(Hps, &(StemPts[2]));
  6745.  
  6746.       /* Draw the text offset by bottom and left margins and stem size */
  6747.  
  6748.       Rect.xLeft = BUBBLE_MARGIN_LEFT;
  6749.       Rect.xRight = BblData->TextWidth;
  6750.       if (BblData->OnTop)
  6751.         Rect.yBottom = BUBBLE_MARGIN_BOT+BblData->StemHeight;
  6752.       else
  6753.         Rect.yBottom = BUBBLE_MARGIN_BOT;
  6754.       Rect.yTop = Rect.yBottom + BblData->TextHeight;
  6755.       WinDrawText(Hps, -1, BblData->Text, &Rect, 0L, 0L, DT_LEFT|DT_BOTTOM|DT_TEXTATTRS);
  6756.  
  6757.       WinEndPaint(Hps);  
  6758.       return 0;
  6759.       }
  6760.   }
  6761.  
  6762.   return WinDefWindowProc(hwnd, msg, mp1, mp2);
  6763. }
  6764.  
  6765. //----------------------------------------------------------------------------
  6766. void UCMenuReloadAllBitmaps(HWND hwndMenu, UCMDATA *UCMData)
  6767. //----------------------------------------------------------------------------
  6768. // Reload all the menu bitmaps calling ourself recursively for submenus.
  6769. //----------------------------------------------------------------------------
  6770. {
  6771.   MENUITEM      Mi;          // PM menu item data
  6772.   UCMITEM       *UCMItem;    // UCMenus item data
  6773.   USHORT        NbOfItems;   // # of items in this menu
  6774.   USHORT        i, itemID;
  6775.  
  6776.   NbOfItems = SHORT1FROMMR(WinSendMsg(hwndMenu, MM_QUERYITEMCOUNT, NULL, NULL));
  6777.  
  6778.   for (i=0 ; i<NbOfItems ; i++ ) {
  6779.     itemID = (USHORT)WinSendMsg(hwndMenu,
  6780.                                 MM_ITEMIDFROMPOSITION,
  6781.                                 MPFROMSHORT(i),
  6782.                                 NULL);
  6783.     WinSendMsg(hwndMenu,
  6784.                MM_QUERYITEM,
  6785.                MPFROM2SHORT(itemID, FALSE),
  6786.                MPFROMP(&Mi));
  6787.  
  6788.     /* If there is valid UCMenu item data, delete current bitmap */
  6789.     /* and reload it.                                            */
  6790.  
  6791.     UCMItem = (UCMITEM *)Mi.hItem;
  6792.     if (UCMItem != NULL) {
  6793.       if (UCMItem->hBmp != NULLHANDLE) {
  6794.         GpiDeleteBitmap(UCMItem->hBmp);
  6795.         UCMItem->hBmp = NULLHANDLE;
  6796.       }
  6797.       UCMenuLoadItemBmp(&Mi, UCMData);
  6798.     }
  6799.  
  6800.     /* If this is a submenu item, call again for submenu */
  6801.  
  6802.     if (Mi.afStyle & MIS_SUBMENU) 
  6803.       UCMenuReloadAllBitmaps(Mi.hwndSubMenu, UCMData);
  6804.  
  6805.   } // for each item in menu
  6806. }
  6807.  
  6808.  
  6809. //----------------------------------------------------------------------------
  6810. // MenuWndProc
  6811. //----------------------------------------------------------------------------
  6812. // :pfunction res=&IDF_MENUWNDPROC. name='MenuWndProc' text='Menu window procedure'.
  6813. // Window procedure of the menus
  6814. // :syntax name='MenuWndProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  6815. // :fparams.
  6816. // :fparam name='hwnd' type='HWND' io='input' .
  6817. // Menu window handle
  6818. // :fparam name='msg' type='ULONG' io='input' .
  6819. // Message
  6820. // :fparam name='mp1' type='MPARAM' io='input'.
  6821. // First parameter
  6822. // :fparam name='mp2' type='MPARAM' io='input'.
  6823. // Second parameter
  6824. // :freturns.
  6825. // :fparam name='mresult' type='MRESULT' io='return'.
  6826. // Return code of a PM message.
  6827. // :efparams.
  6828. // :remarks.
  6829. // :epfunction.
  6830. //----------------------------------------------------------------------------
  6831. MRESULT EXPENTRY MenuWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  6832. {
  6833. PUCMDATA  UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  6834.  
  6835.    switch (msg) {
  6836.      #if defined(MSG_DEBUGMESSAGE)
  6837.      case MSG_DEBUGMESSAGE:
  6838.        WinMessageBox(HWND_DESKTOP,hwnd,(char *)mp2,(char *)mp1,0,MB_OK|MB_INFORMATION);
  6839.        return 0;
  6840.      #endif
  6841.  
  6842.     case WM_MOUSEMOVE: {
  6843.           USHORT   usId;      /* ID of menu item under mouse */
  6844.           POINTL   ptl;       /* Mouse position in the window */
  6845.  
  6846.           /* If our app is not the active window, just pass it on */
  6847.           if (!(UCMData->Active))
  6848.             return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 );
  6849.  
  6850.           /* See what item the mouse is over */
  6851.           ptl.x = (ULONG) SHORT1FROMMP( mp1 );
  6852.           ptl.y = (ULONG) SHORT2FROMMP( mp1 );
  6853.           usId  = UCMenuIdFromCoord(hwnd, &ptl );
  6854.  
  6855.           /* If mouse has moved to a different item, send notifications */
  6856.  
  6857.           if (usId != UCMData->HoverID) {            
  6858.             if (UCMData->Style & UCS_PROMPTING)     // Tell owner if they want to know
  6859.               WinSendMsg( UCMData->hwndOwner, WM_CONTROL,
  6860.                           MPFROM2SHORT( UCMData->UCMenuID, UCN_MOUSEMOVE ),
  6861.                           MPFROMSHORT( usId ) );
  6862.  
  6863.             if (UCMData->Style & UCS_BUBBLEHELP)    // Tell bubble if it needs to know
  6864.               WinSendMsg(UCMData->hwndBubble,           
  6865.                           MSG_ITEMCHANGE, MPFROM2SHORT(usId, FALSE), MPFROMHWND(hwnd));
  6866.           }
  6867.           UCMData->HoverID = usId;                  // Save for next time
  6868.  
  6869.           /* Start/reset timer to check that pointer is still in this window */
  6870.           if ((UCMData->Style & UCS_PROMPTING) || (UCMData->Style & UCS_BUBBLEHELP))
  6871.             UCMData->MenuPtrTimer = WinStartTimer((HAB)0, hwnd, TIMER_PTRCHECK, PTR_CHECK_DELAY);
  6872.  
  6873.           return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  6874.           }
  6875.  
  6876.     case WM_BUTTON2DOWN:
  6877.     case WM_BUTTON1DOWN:
  6878.           /* On any button down, disable the bubble help window.  It  */
  6879.           /* will be re-enabled when the button is released (or       */
  6880.           /* drag/drop done, in that case).                           */
  6881.   
  6882.           if (UCMData->Style & UCS_BUBBLEHELP)
  6883.             WinSendMsg(UCMData->hwndBubble, MSG_DISABLE_BUBBLE, 0L, 0L);
  6884.  
  6885.           /* Don't pass button 2 to real menu proc since it will attempt to */
  6886.           /* select the item.  We also have to return FALSE or drag/drop    */
  6887.           /* will not work (no WM_BEGINDRAG will occure).  So for button 2  */
  6888.           /* we must do what the default window proc normally does (e.g.    */
  6889.           /* activate the frame window).                                    */
  6890.           if (msg == WM_BUTTON2DOWN) {
  6891.             WinSetActiveWindow(HWND_DESKTOP, hwnd);  // Will activate my frame
  6892.             return FALSE;                            // Tell PM we did not process it
  6893.           }
  6894.  
  6895.           /* For button 1, let normal menu proc handle as usual */
  6896.  
  6897.           return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  6898.  
  6899.     case WM_BUTTON2UP:
  6900.     case WM_BUTTON1UP: {
  6901.           MRESULT rc;
  6902.   
  6903.           /* First let normal window proc process the UP message */
  6904.           /* It will POST a WM_COMMAND to our UCMenu window if   */
  6905.           /* the mouse is still on the menu item.                */
  6906.           rc = UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); 
  6907.   
  6908.           /* Simulate a mouse-move so that we will restart the   */
  6909.           /* bubble-help window.                                 */
  6910.   
  6911.           if (UCMData->Style & UCS_BUBBLEHELP)
  6912.             WinSendMsg(UCMData->hwndBubble, MSG_ENABLE_BUBBLE, 0L, 0L);
  6913.   
  6914.           /* NOTE: This message must be POSTED so it arrives         */
  6915.           /* after WM_COMMAND has been received and UCN_ITEMSELECTED */
  6916.           /* processed by the application.                           */
  6917.           //...need to see if ptr is still in the window before doing
  6918.           //...this since MOUSEMOVE code assumes ptr is in the window.
  6919.   
  6920.           WinPostMsg(hwnd, WM_MOUSEMOVE, mp1, mp2);
  6921.           return rc;
  6922.           }
  6923.  
  6924.     case WM_TIMER: {
  6925.           POINTL Point;
  6926.  
  6927.        // if (SHORT1FROMMP(mp1) == TIMER_SYSCLRCHANGE) {
  6928.        //       UCMenuReloadAllBitmaps(WinQueryWindow( hwnd, QW_OWNER ), UCMData);
  6929.        //       UCMenuUpdateMenu( hwnd, FALSE );
  6930.        //       WinStopTimer((HAB)0, hwnd, TIMER_SYSCLRCHANGE);
  6931.        //       return 0;
  6932.        //  }
  6933.        //  else if (SHORT1FROMMP(mp1) != TIMER_PTRCHECK) // Pass on other timer events
  6934.            if (SHORT1FROMMP(mp1) != TIMER_PTRCHECK) // Pass on other timer events
  6935.              break;
  6936.  
  6937.           /* See if the pointer is still in the window.  If not, */
  6938.           /* notify the owner and bubble help windows.  Also, if */
  6939.           /* application became inactive.                        */
  6940.           WinQueryPointerPos(HWND_DESKTOP, &Point);
  6941.  
  6942.           if ((WinWindowFromPoint(HWND_DESKTOP, &Point, TRUE) != hwnd) ||
  6943.              (!UCMData->Active)) {
  6944.             BOOL Disable;
  6945.  
  6946.             if (UCMData->Style & UCS_PROMPTING)     // Tell owner if they want to know
  6947.               WinSendMsg( UCMData->hwndOwner, WM_CONTROL,
  6948.                           MPFROM2SHORT(UCMData->UCMenuID, UCN_MOUSEMOVE ),
  6949.                           MPFROMSHORT( 0 ) );
  6950.   
  6951.             //...should disable bubble only if new window is not part of the
  6952.             //...UCMenu control (e.g. not the menu, submenu, or hide window).
  6953.             Disable = TRUE;
  6954.             if (UCMData->Style & UCS_BUBBLEHELP)    // Tell bubble to disable itself
  6955.               WinSendMsg(UCMData->hwndBubble,           
  6956.                           MSG_ITEMCHANGE, MPFROM2SHORT(0, Disable), MPFROMHWND(hwnd));
  6957.             UCMData->HoverID = 0;                   // Save for next time
  6958.  
  6959.             WinStopTimer((HAB)0, hwnd, UCMData->MenuPtrTimer);
  6960.           }
  6961.           return 0;
  6962.           }
  6963.  
  6964. //  case WM_BUTTON2DOWN:
  6965. //  case WM_BUTTON1DOWN: {
  6966. //        /* On any button down, release capture and disable the bubble  */
  6967. //        /* help window.  It will be re-enabled when the button is      */
  6968. //        /* released (or drag/drop done, in that case).                 */
  6969. //
  6970. //        if (UCMData->Style & UCS_BUBBLEHELP)
  6971. //          WinSendMsg(UCMData->hwndBubble, MSG_DISABLE_BUBBLE, 0L, 0L);
  6972. //
  6973. //        if (UCMData->HoverCapture) {
  6974. //          WinSetCapture(HWND_DESKTOP, NULLHANDLE);
  6975. //          UCMData->HoverCapture = FALSE;
  6976. //        }
  6977. //        
  6978. //        if (msg == WM_BUTTON2DOWN)  // Drag/drop does not work if default proc gets this
  6979. //          break;                    // ??? should use WinQuerySysValue(...SV_BEGINDRAG...)
  6980. //        return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  6981. //        }
  6982. //
  6983. //  case WM_BUTTON2UP:
  6984. //  case WM_BUTTON1UP: {
  6985. //        MRESULT rc;
  6986. //
  6987. //        /* First let normal window proc process the UP message */
  6988. //        /* It will POST a WM_COMMAND to our UCMenu window if   */
  6989. //        /* the mouse is still on the menu item.                */
  6990. //        rc = UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); 
  6991. //
  6992. //        /* Simulate a mouse-move so that we will recapture the */
  6993. //        /* mouse if needed.  Set a flag for the WM_MOUSEMOVE   */
  6994. //        /* code to recognize this is a fake movement.          */
  6995. //
  6996. //        UCMData->HoverMsg = msg;
  6997. //        if (UCMData->Style & UCS_BUBBLEHELP)
  6998. //          WinSendMsg(UCMData->hwndBubble, MSG_ENABLE_BUBBLE, 0L, 0L);
  6999. //
  7000. //        /* NOTE: This message must be POSTED so it arrives         */
  7001. //        /* after WM_COMMAND has been received and UCN_ITEMSELECTED */
  7002. //        /* processed by the application.  Otherwise the app could  */
  7003. //        /* invoke a dialog in response to UCN_ITEMSELECTED and     */
  7004. //        /* cause us to lose mouse capture tracking.                */
  7005. //
  7006. //        WinPostMsg(hwnd, WM_MOUSEMOVE, mp1, mp2);
  7007. //        return rc;
  7008. //        }
  7009. //     
  7010. //  case WM_MOUSEMOVE:
  7011. //     {
  7012. //        USHORT   usId;      /* ID of menu item under mouse */
  7013. //        POINTL   ptl;       /* Mouse position in the window */
  7014. //        HWND hwndUCM   = WinQueryWindow( hwnd, QW_OWNER );
  7015. //        HWND hwndOwner = WinQueryWindow( hwndUCM, QW_OWNER );
  7016. //        HWND HwndAt;        /* Window at mouse position */
  7017. //        BOOL Inside    = TRUE;
  7018. //        BOOL ButtonDown= FALSE;
  7019. //
  7020. //        /* If our app is not the active window, just pass it on */
  7021. //        if (!(UCMData->Active))
  7022. //          return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 );
  7023. //
  7024. //        /* See if any mouse button is pressed (and this is not from a BUTTONUP msg above). */
  7025. //        if ((WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & 0x8000) && (UCMData->HoverMsg != WM_BUTTON1UP))
  7026. //          ButtonDown = TRUE;
  7027. //        if ((WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000) && (UCMData->HoverMsg != WM_BUTTON2UP))
  7028. //          ButtonDown = TRUE;
  7029. //        UCMData->HoverMsg = WM_NULL;
  7030. //
  7031. //        ptl.x = (ULONG) SHORT1FROMMP( mp1 );
  7032. //        ptl.y = (ULONG) SHORT2FROMMP( mp1 );
  7033. //
  7034. //        /* Note we must test entire desktop window hierarchy for PM */
  7035. //        /* to tell us if the point is over a window which obscures  */
  7036. //        /* our own.  If we search only our own window hierarchy, we */
  7037. //        /* will detect movements whenever the pointer is inside our */
  7038. //        /* window rectangle, even if our window is covered by       */
  7039. //        /* some other application.  Searching the desktop hierarchy */
  7040. //        /* is bad for performance, but PM gives us no other way to  */
  7041. //        /* detect (for sure) when the mouse leaves our menu window. */
  7042. //
  7043. //        WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1);
  7044. //        HwndAt = WinWindowFromPoint(HWND_DESKTOP, &ptl, TRUE);
  7045. //        if (HwndAt != hwnd)
  7046. //          Inside = FALSE;
  7047. //
  7048. //        /* Restore point to my coordinate system */
  7049. //        ptl.x = (ULONG) SHORT1FROMMP( mp1 );
  7050. //        ptl.y = (ULONG) SHORT2FROMMP( mp1 );
  7051. //
  7052. //        /* If mouse is over another window (even if within the menu */
  7053. //        /* window rectangle), we don't use it.  Coord mapping       */
  7054. //        /* routine will be fooled by overlapping windows.           */
  7055. //
  7056. //        if (!Inside)
  7057. //          usId = 0;
  7058. //        else
  7059. //          usId  = UCMenuIdFromCoord(hwnd, &ptl ); // Where is it?
  7060. //
  7061. //        if (usId != UCMData->HoverID) {               // Tell owner of any change
  7062. //          if (UCMData->Style & UCS_PROMPTING)         // ...if they want to know.
  7063. //            WinSendMsg( hwndOwner, WM_CONTROL,
  7064. //                        MPFROM2SHORT( WinQueryWindowUShort( hwndUCM, QWS_ID ), UCN_MOUSEMOVE ),
  7065. //                        MPFROMSHORT( usId ) );
  7066. //          if (UCMData->Style & UCS_BUBBLEHELP) {      // ...if bubble needs to know
  7067. //            BOOL Deactivate = TRUE;                   // Bubble should be deactivated
  7068. //            if ((HwndAt == UCMData->hwndMenu) ||              // ... unless ptr
  7069. //       //       (HwndAt == UCMData->hwndBubble) ||
  7070. //       //       (HwndAt == WinQueryWindow(UCMData->hwndMenu, QW_PARENT)) ||  // hide window
  7071. //                (WinQueryWindow(HwndAt,QW_OWNER)==UCMData->hwndMenu))  // is over any TB menu
  7072. //                Deactivate = FALSE;
  7073. //            WinSendMsg(UCMData->hwndBubble,           
  7074. //                        MSG_ITEMCHANGE, MPFROM2SHORT(usId, Deactivate), MPFROMHWND(hwnd));
  7075. //          }
  7076. //        }
  7077. //        UCMData->HoverID = usId;                      // Save for next time
  7078. //
  7079. //        /* We (UCMenus) will capture the mouse if:               */
  7080. //        /*  - The mouse is inside the menu window                */
  7081. //        /*  - We don't already have it captured                  */
  7082. //        /*  - No buttons are pressed                             */
  7083. //
  7084. //        if ((Inside) && (!UCMData->HoverCapture) && (!ButtonDown)) {
  7085. //           WinSetCapture(HWND_DESKTOP, hwnd);
  7086. //           UCMData->HoverCapture = TRUE;
  7087. //        }
  7088. //
  7089. //        /* We release capture if:                                */
  7090. //        /*  - Mouse is outside the menu window                   */
  7091. //        /*  - No buttons down                                    */
  7092. //        /*  - We have capture set                                */
  7093. //
  7094. //        if ((!Inside) && (!ButtonDown) && (UCMData->HoverCapture)) {
  7095. //           WinSetCapture(HWND_DESKTOP, NULLHANDLE);    // Stop capture
  7096. //           UCMData->HoverCapture = FALSE;              // No longer captured
  7097. //           UCMData->HoverID = 0;
  7098. //        }
  7099. //
  7100. //        return UCMData->OldMenuProc( hwnd, msg, mp1, mp2 ); // Pass this on
  7101. //     }
  7102.  
  7103.     case MM_INSERTITEM:
  7104.     case MM_SETITEM:
  7105.        {
  7106.           PMENUITEM pMi = 0;
  7107.           USHORT    NewID;
  7108.  
  7109.           switch (msg) {
  7110.           case MM_INSERTITEM:
  7111.              pMi = (PMENUITEM)mp1;
  7112.              // Check if the id is already used
  7113.              NewID = UCMenuGetNewID( UCMData->hwndMenu, pMi->id, UCMData );
  7114.              if ( NewID != pMi->id) {
  7115.                 pMi->id = NewID;
  7116.                 if ( pMi->hItem ){
  7117.                    ITEM( pMi, usId ) = NewID;
  7118.                 } // endif
  7119.              } /* endif */
  7120.              break;
  7121.           case MM_SETITEM:
  7122.              pMi = (PMENUITEM)mp2;
  7123.             break;
  7124.           } // endswitch
  7125.  
  7126.           //(MAM) set MIA_NODISMISS attribute on all submenu placeholder items to
  7127.           // prevent dismiss of submenu during drag/drop and context menu operations.
  7128.           if (pMi->afStyle & MIS_SUBMENU)
  7129.             pMi->afAttribute = pMi->afAttribute | MIA_NODISMISS;
  7130.  
  7131.           //(MAM) remove MIS_BREAK from all items
  7132.           pMi->afStyle = pMi->afStyle & (USHORT) ~MIS_BREAK;
  7133.  
  7134.           if ( pMi && pMi->hItem ){
  7135.              // Set the id also in ucmitem
  7136.              // --
  7137.              ITEM( pMi, usId ) = pMi->id;
  7138.              // Load the bitmap
  7139.              // --
  7140.              UCMenuLoadItemBmp(pMi, UCMData );
  7141.           } // endif
  7142.  
  7143.           return UCMData->OldMenuProc(hwnd, msg, mp1, mp2);
  7144.        }
  7145.      case WM_TRANSLATEACCEL:
  7146.           {
  7147.              PQMSG       QMsg       = (PQMSG)mp1;
  7148.  
  7149.              if(QMsg->msg == WM_CHAR) {
  7150.                 USHORT flags = SHORT1FROMMP(QMsg->mp1);
  7151.                 USHORT VK = SHORT2FROMMP(QMsg->mp2);
  7152.  
  7153.                 if((flags & KC_SHIFT) && !(flags & KC_PREVDOWN) && (flags & KC_VIRTUALKEY) && !(flags & KC_LONEKEY)) {
  7154.                   if(VK == VK_F10) {
  7155.                      WinSendMsg(hwnd, WM_CONTEXTMENU, (MPARAM)0, 0L);
  7156.                      return((MRESULT)0);
  7157.                   }
  7158.                 }
  7159.                 if(!(flags & KC_PREVDOWN) && (flags & KC_VIRTUALKEY) && (VK==VK_F1)) {
  7160.                      RECTL Rectl;
  7161.                      POINTL ptl;
  7162.                      ULONG ContextID;
  7163.                      ULONG SelectedItem = (ULONG) WinSendMsg(hwnd, MM_QUERYSELITEMID, 0L, 0L);
  7164.  
  7165.                      WinSendMsg(hwnd, MM_QUERYITEMRECT, (MPARAM)SelectedItem, MPFROMP(&Rectl));
  7166.                      ptl.x = Rectl.xLeft   + (Rectl.xRight - Rectl.xLeft)/2;
  7167.                      ptl.y = Rectl.yBottom + (Rectl.yTop - Rectl.yBottom)/2;
  7168.                      ContextID = UCMenuIdFromCoord(hwnd, &ptl);
  7169.                      WinSendMsg( UCMData->hwndOwner,
  7170.                                  WM_HELP,
  7171.                                  MPFROM2SHORT( ContextID, UCMData->UCMenuID),
  7172.                                  MPFROM2SHORT( CMDSRC_UCMENU, 0 ) );
  7173.                      return((MRESULT)0);
  7174.                 }
  7175.  
  7176.                 if(!(flags & KC_PREVDOWN) && (flags & KC_CHAR)) {
  7177.                    return (MRESULT) TranslateAccel(UCMData, hwnd, SHORT1FROMMP(QMsg->mp2), QMsg);
  7178.                 }
  7179.  
  7180.                 return (UCMenuDrgDrpMsg(UCMData, hwnd, msg, mp1, mp2, UCMData->OldMenuProc));
  7181.              }
  7182.           } // endcase
  7183.           return(MRESULT)0;
  7184.     case WM_CONTEXTMENU:
  7185.        UCMenuContextMenu(UCMData->hwndUCM,
  7186.                          hwnd,
  7187.                          (ULONG)mp1);
  7188.        return (MRESULT) TRUE;
  7189.  
  7190.      case WM_BUTTON2DBLCLK:
  7191.        break;
  7192.  
  7193. //   case WM_BUTTON2DOWN:
  7194. //     // ----------------------------------------------------------------
  7195. //     // -- Keep that message here, else drag and drop won't work
  7196. //     // -- (this prevent the message from being processed by the default
  7197. //     // -- menu window procedure)
  7198. //     // ----------------------------------------------------------------
  7199. //     break;
  7200.  
  7201.      case WM_SYSCOLORCHANGE:
  7202.        // Don't let original menu window proc get this since we handle
  7203.        // color changes ourself.
  7204.        return((MRESULT)0);
  7205.  
  7206.      case WM_PRESPARAMCHANGED:
  7207.           {
  7208.              ULONG x;
  7209.  
  7210.              if ((LONG)mp1 == PP_MENUBACKGROUNDCOLOR) {
  7211.                 // We will also receive 2 messages for the menu bg hilite and menu bg disabled colors
  7212.                 // We don't need them so we don't process them
  7213.                 LONG lColor;
  7214.                 LONG lNearestColor;
  7215.                 HPS hps;
  7216.  
  7217.                 WinQueryPresParam( hwnd,
  7218.                                    (SHORT)mp1,
  7219.                                    0L, &x,
  7220.                                    (ULONG)sizeof lColor,
  7221.                                    &lColor,
  7222.                                    QPF_NOINHERIT );
  7223.                 if (x == (SHORT)mp1) {
  7224.                    hps = WinGetPS( hwnd );
  7225.                    lNearestColor = GpiQueryNearestColor( hps, (ULONG)0, (LONG)lColor );
  7226.                    WinReleasePS( hps );
  7227.  
  7228.                    if ( lColor == lNearestColor ) {
  7229.                       // -- Update the color
  7230.                       UCMData->ItemBgColor = lColor;
  7231.  
  7232.                       // -- When background color changes, must reload all bitmaps
  7233.                       // -- to get mapping from original bitmap colors (not current
  7234.                       // -- colors).
  7235.                       UCMenuReloadAllBitmaps(UCMData->hwndUCM, UCMData);
  7236.  
  7237.                       // -- Warn the owner
  7238.                       WinSendMsg( UCMData->hwndOwner,
  7239.                                   WM_CONTROL,
  7240.                                   MPFROM2SHORT( UCMData->UCMenuID, UCN_COLOR ),
  7241.                                   MPFROMSHORT( 0 ) );
  7242.  
  7243.                       // This will cause a WM_UPDATEFRAME to be sent to the owner (the ucmenu)
  7244.                       // If we were processing the 2 following PP_* in the same way, we would have
  7245.                       // the ucmenu repainted 3 times (pretty ugly isn't it? :-) )
  7246.                       UCMData->bProcessingPP = TRUE;
  7247.                       return UCMData->OldMenuProc( hwnd, msg, mp1, mp2);
  7248.                    } else {
  7249.                       // -----------------------------
  7250.                       // -- We want only solid colors
  7251.                       // -----------------------------
  7252.                       WinSetPresParam( hwnd,
  7253.                                        PP_MENUBACKGROUNDCOLOR,
  7254.                                        sizeof lNearestColor,
  7255.                                        &lNearestColor);
  7256.                       return (MRESULT)FALSE;
  7257.                    } // endif
  7258.                 } else {
  7259.                    WinRemovePresParam( hwnd, PP_MENUBACKGROUNDCOLOR );
  7260.                 } // endif
  7261.              } else if (LONGFROMMP(mp1) == PP_FONTNAMESIZE) {
  7262.                 char FontNameSize[MAX_FONTNAMELEN] ;
  7263.                 WinQueryPresParam( hwnd,
  7264.                                    PP_FONTNAMESIZE,
  7265.                                    0L, &x,
  7266.                                    (ULONG)MAX_FONTNAMELEN,
  7267.                                    FontNameSize,
  7268.                                    QPF_NOINHERIT );
  7269.                 if (x == PP_FONTNAMESIZE) {
  7270.                    // A font pres parameter was set... update our font info
  7271.                    if (UCMData->pszFontNameSize)
  7272.                       MyFree(UCMData->pszFontNameSize);
  7273.                    if ( UCMData->pszFontNameSize = MyMalloc(strlen(FontNameSize)+1) ) {
  7274.                       strcpy(UCMData->pszFontNameSize, FontNameSize );
  7275.                       WinSendMsg( UCMData->hwndOwner,
  7276.                                   WM_CONTROL,
  7277.                                   MPFROM2SHORT( UCMData->UCMenuID, UCN_FONT ),
  7278.                                   MPFROMSHORT( 0 ) );
  7279.                       /* Tell the bubble-help window about font changes */
  7280.                       if (UCMData->Style & UCS_BUBBLEHELP)
  7281.                         WinSetPresParam(UCMData->hwndBubble, PP_FONTNAMESIZE, strlen(FontNameSize)+1, FontNameSize);
  7282.                    }
  7283.                    UCMData->bProcessingPP = TRUE;
  7284.                    return UCMData->OldMenuProc( hwnd, msg, mp1, mp2);
  7285.                    // This will cause a WM_UPDATEFRAME to be sent to the owner (the ucmenu)
  7286.                 } else {
  7287.                    // The font pres parameter was removed.
  7288.                    WinRemovePresParam( hwnd, PP_FONTNAMESIZE );
  7289.                    /* Tell the bubble-help window about font changes */
  7290.                    if (UCMData->Style & UCS_BUBBLEHELP)
  7291.                      WinRemovePresParam( UCMData->hwndBubble, PP_FONTNAMESIZE );
  7292.                 } // if FONTNAMESIZE param was set
  7293.  
  7294.              } else {
  7295.                 break;
  7296.              } // endif
  7297.           }
  7298.           return UCMData->OldMenuProc( hwnd, msg, mp1, mp2);
  7299.  
  7300.      default:
  7301.        {
  7302.           return (UCMenuDrgDrpMsg(UCMData, hwnd, msg, mp1, mp2, UCMData->OldMenuProc));
  7303.        }
  7304.    } // endswitch
  7305.  
  7306.    return (MRESULT)0;
  7307. }
  7308.  
  7309. //----------------------------------------------------------------------------
  7310. // UCMenuLoadItemBmp
  7311. //----------------------------------------------------------------------------
  7312. // :pfunction res=&IDF_UCMLOADITEMBMP. name='UCMenuLoadItemBmp' text='Find and load the bitmap of a ucmenu item'.
  7313. // If a ucmenu item has no bitmap, find it and load it.
  7314. // :syntax name='UCMenuLoadItemBmp' params='pUCMitem, pUCMData' return='nothing' .
  7315. // :fparams.
  7316. // :fparam name='pUCMItem' type='PUCMITEM' io='input/output' .
  7317. // Pointer to a ucmenu item structure.
  7318. // :fparam name='pUCMData' type='PUCMDATA' io='input' .
  7319. // Pointer to the ucmenu data structure.
  7320. // :freturns.
  7321. // :fparam name='-' type='VOID' io='return'.
  7322. // Nothing.
  7323. // :efparams.
  7324. // :remarks.
  7325. // :epfunction.
  7326. //----------------------------------------------------------------------------
  7327. VOID _Optlink UCMenuLoadItemBmp( MENUITEM *Item, PUCMDATA UCMData )
  7328. {
  7329. UCMITEM *pUCMI = NULL;
  7330.  
  7331.    if (Item)
  7332.      pUCMI = (UCMITEM *)Item->hItem;  // Get ptr to UCMITEM from menu item struct
  7333.  
  7334.    /* Don't load bitmap if pointers are invalid, there is already */
  7335.    /* a bitmap loaded, or this is a SPACER type item.             */
  7336.  
  7337.    if ( pUCMI && !pUCMI->hBmp && !(Item->afStyle & MIS_SPACER) ) {
  7338.       char  BmpPathStr[MAXPATHL];
  7339.       HPS hPS = WinGetPS( UCMData->hwndMenu );
  7340.       LONG lID = 0;
  7341.       BOOL BinOK;
  7342.  
  7343.       if (pUCMI->pszBmp ){
  7344.    
  7345.         /* A bitmap string was specified.  It may be a resource ID or */
  7346.         /* a BMP file name.                                           */
  7347.     
  7348.         /* Attempt conversion of bitmap string to resource ID */
  7349.         lID = UCMString2Int(pUCMI->pszBmp, &BinOK);
  7350.     
  7351.         if (BinOK) { // Bitmap is a resource ID, so load it from resources
  7352.           pUCMI->hBmp = (ULONG)GpiLoadBitmap(hPS,
  7353.                                              UCMData->hModBmp,
  7354.                                              lID,
  7355.                                              0,
  7356.                                              0);
  7357.           pUCMI->ulFlags &= ~UCMI_BMPFROMFILE;
  7358.           pUCMI->ulFlags = (pUCMI->ulFlags & 0x0000FFFFL) | (lID << 16);
  7359.         }
  7360.         else { // Bitmap is a file name, so load it from file
  7361.            UCMenuGetBitmapFullName( UCMData, pUCMI->pszBmp, BmpPathStr );
  7362.            pUCMI->hBmp = UCMenuLoadBitmap( BmpPathStr );
  7363.            pUCMI->ulFlags |= UCMI_BMPFROMFILE;
  7364.            pUCMI->ulFlags = pUCMI->ulFlags & 0x0000FFFFL;
  7365.         }
  7366.       } // a pszBmp string was specified
  7367.       else {
  7368.            pUCMI->ulFlags &= ~UCMI_BMPFROMFILE;
  7369.            pUCMI->ulFlags = pUCMI->ulFlags & 0x0000FFFFL;
  7370.       }
  7371.  
  7372.       /* If bitmap could not be loaded, load default as specified in UCMINFO */
  7373.    
  7374.       if (!pUCMI->hBmp) {
  7375.         /* Attempt conversion of bitmap string to resource ID */
  7376.         lID = UCMString2Int(UCMData->szDefaultBitmap, &BinOK);
  7377.         if (BinOK) { // Bitmap is a resource ID, so load it from resources
  7378.           pUCMI->hBmp = (ULONG)GpiLoadBitmap(hPS,
  7379.                                              UCMData->hModBmp,
  7380.                                              lID,
  7381.                                              0,
  7382.                                              0);
  7383.         }
  7384.         else { // Bitmap is a file name, so load it from file
  7385.            UCMenuGetBitmapFullName( UCMData, UCMData->szDefaultBitmap, BmpPathStr );
  7386.            pUCMI->hBmp = UCMenuLoadBitmap( BmpPathStr );
  7387.         }
  7388.       }
  7389.    
  7390.       /* Finally, if still no go, use our own default bitmap resource */
  7391.    
  7392.       if ( !pUCMI->hBmp )
  7393.         pUCMI->hBmp = GpiLoadBitmap( hPS, UCMData->hModUCM, UCMENUID_DEFAULTBMP, 0, 0 );
  7394.  
  7395.       // If we are mapping background colors, do the mapping now
  7396.  
  7397.       if (UCMData->Style & (UCS_CHNGBMPBG|UCS_CHNGBMPBG_AUTO))
  7398.         UCMenuSetBmpBgColor(pUCMI, UCMData, hPS);
  7399.  
  7400.       WinReleasePS( hPS );
  7401.  
  7402.    } // if data is valid
  7403. }
  7404.  
  7405. #if defined(UCMUI)
  7406. //----------------------------------------------------------------------------
  7407. // UCMenuSettingsDlgProc
  7408. //----------------------------------------------------------------------------
  7409. // :pfunction res=&IDF_UCMSETTDLGPROC. name='UCMenuSettingsDlgProc' text='UCMenu settings notebook dialog procedure'.
  7410. // Dialog procedure of the ucmenu settings notebook
  7411. // :syntax name='UCMenuSettingsDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  7412. // :fparams.
  7413. // :fparam name='hwnd' type='HWND' io='input' .
  7414. // Notebook window handle
  7415. // :fparam name='msg' type='ULONG' io='input' .
  7416. // Message
  7417. // :fparam name='mp1' type='MPARAM' io='input'.
  7418. // First parameter
  7419. // :fparam name='mp2' type='MPARAM' io='input'.
  7420. // Second parameter
  7421. // :freturns.
  7422. // :fparam name='mresult' type='MRESULT' io='return'.
  7423. // Return code of a PM message.
  7424. // :efparams.
  7425. // :remarks.
  7426. // :epfunction.
  7427. //----------------------------------------------------------------------------
  7428. MRESULT EXPENTRY  UCMenuSettingsDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  7429. {
  7430.   switch (msg) {
  7431.     case WM_CONTROL:
  7432.       switch (SHORT2FROMMP(mp1)) {
  7433.       case BKN_PAGESELECTED:
  7434.          // The last focused window of a page is stored in its QWL_USER
  7435.          // The QWL_USER is initialized in the WM_INITDLG of each page
  7436.          {
  7437.             PAGESELECTNOTIFY notif =  * (PAGESELECTNOTIFY *)mp2;
  7438.             HWND hNewPage = (HWND)WinSendMsg( notif.hwndBook,
  7439.                                      BKM_QUERYPAGEWINDOWHWND,
  7440.                                      MPFROMLONG( notif.ulPageIdNew),
  7441.                                      MPFROMLONG(0L));
  7442.  
  7443.             if (hNewPage) {
  7444.                WinPostMsg( hNewPage, GETTING_FOCUS, 0L, 0L );
  7445.             } // endif
  7446.          }
  7447.  
  7448.  
  7449.          break;
  7450.       default:
  7451.         break;
  7452.       } // endswitch
  7453.       break;
  7454.  
  7455.     case WM_INITDLG:
  7456.       { HWND hwndPage;
  7457.         RECTL rcl;
  7458.         SWP swp;
  7459.         POINTL pt[2];
  7460.         HWND hwndNB = WinWindowFromID(hwnd, IDC_UCMNB);
  7461.         LONG PageID1, PageID2, PageID0;
  7462.         ULONG Color = SYSCLR_WINDOWSTATICTEXT;
  7463.         PUCMDATA UCMData = (PUCMDATA)mp2;
  7464.  
  7465. //      if ( UCMData->hwndHelpInstance ) {
  7466. //         // -------------------------------------------------
  7467. //         // -- The contextual help would work without that
  7468. //         // -- We do it so that the focus goes back on this
  7469. //         // -- dialog after a contextual help invoked from it
  7470. //         // -- has been dismissed ( else the focus goes back
  7471. //         // -- to the closest winassociated window in the
  7472. //         // -- parent and owner chain )
  7473. //         // -------------------------------------------------
  7474. //         WinAssociateHelpInstance( UCMData->hwndHelpInstance, hwnd );
  7475. //      } // endif
  7476.         WinSetWindowULong(hwnd, QWL_USER, (ULONG)UCMData);
  7477.         UCMData->hwndSettings = hwnd;
  7478.  
  7479.         WinSendMsg(hwndNB, BKM_SETNOTEBOOKCOLORS,
  7480.                    MPFROMLONG(SYSCLR_DIALOGBACKGROUND),
  7481.                    MPFROMLONG(BKA_BACKGROUNDMAJORCOLORINDEX));
  7482.         WinSendMsg(hwndNB, BKM_SETNOTEBOOKCOLORS,
  7483.                    MPFROMLONG(SYSCLR_DIALOGBACKGROUND),
  7484.                    MPFROMLONG(BKA_BACKGROUNDMINORCOLORINDEX));
  7485.         WinSendMsg(hwndNB, BKM_SETNOTEBOOKCOLORS,
  7486.                    MPFROMLONG(SYSCLR_DIALOGBACKGROUND),
  7487.                    MPFROMLONG(BKA_BACKGROUNDPAGECOLORINDEX));
  7488.         WinSetPresParam(hwndNB, PP_FOREGROUNDCOLORINDEX, 4 , &Color);
  7489.         /*┌──────────────────────────────────────────────────────────────┐
  7490.           │ Insert the pages (2 or 3) in the notebook control            │
  7491.           └──────────────────────────────────────────────────────────────┘*/
  7492.         if (UCMData->bItemCreation) {
  7493.           PageID0 = (LONG)WinSendMsg(hwndNB,
  7494.                                       BKM_INSERTPAGE,
  7495.                                       (MPARAM)0,
  7496.                                       MPFROM2SHORT(BKA_MAJOR | BKA_AUTOPAGESIZE, BKA_FIRST));
  7497.         } /* endif */
  7498.         PageID1 = (LONG) WinSendMsg(hwndNB,
  7499.                                     BKM_INSERTPAGE,
  7500.                                     (MPARAM)0,
  7501.                                     MPFROM2SHORT(BKA_MAJOR | BKA_AUTOPAGESIZE, BKA_LAST));
  7502.         PageID2 = (LONG) WinSendMsg(hwndNB,
  7503.                                     BKM_INSERTPAGE,
  7504.                                     (MPARAM)0,
  7505.                                     MPFROM2SHORT(BKA_MAJOR | BKA_AUTOPAGESIZE, BKA_LAST));
  7506.         /*┌──────────────────────────────────────────────────────────────┐
  7507.           │ Set the tabs dimensions                                      │
  7508.           └──────────────────────────────────────────────────────────────┘*/
  7509.         WinSendMsg(hwndNB,
  7510.                    BKM_SETDIMENSIONS,
  7511.                    MPFROM2SHORT(90,30),
  7512.                    (MPARAM)BKA_MAJORTAB);
  7513.         WinSendMsg(hwndNB,
  7514.                    BKM_SETDIMENSIONS,
  7515.                    MPFROM2SHORT(0,0),
  7516.                    (MPARAM)BKA_MINORTAB);
  7517.         /*┌──────────────────────────────────────────────────────────────┐
  7518.           │ Get the coord. of the client area                            │
  7519.           └──────────────────────────────────────────────────────────────┘*/
  7520.         pt[0].x =   0;  //
  7521.         pt[0].y =   0;  // coord of the corners of the nb pages (dialogs)
  7522.         pt[1].x = 203;  //  in the rc file -- all are the same size
  7523.         pt[1].y = 136;  //
  7524.  
  7525.         WinMapDlgPoints( hwndNB, pt, 2, 1 );        // dlg to NB control
  7526.  
  7527.         rcl.xLeft    = pt[0].x;
  7528.         rcl.yBottom  = pt[0].y;
  7529.         rcl.xRight   = pt[1].x;
  7530.         rcl.yTop     = pt[1].y;
  7531.  
  7532.         // get the size to give to the NB control
  7533.         WinSendMsg(hwndNB,
  7534.                    BKM_CALCPAGERECT,
  7535.                    MPFROMP(&rcl),
  7536.                    (MPARAM)FALSE);
  7537.  
  7538.         // size the NB control to fit around the pages
  7539.         WinSetWindowPos( hwndNB,
  7540.                          HWND_TOP,
  7541.                          0,
  7542.                          0,
  7543.                          rcl.xRight-rcl.xLeft,
  7544.                          rcl.yTop-rcl.yBottom,
  7545.                          SWP_SIZE );
  7546.  
  7547.         // Size the dialog window to fit around the NB control
  7548.         // (MAM) but account for the OK/Cancel buttons below it.
  7549.         WinQueryWindowPos( hwndNB, &swp );
  7550.         rcl.xLeft = 0;
  7551.         rcl.yBottom = 0;
  7552.         rcl.xRight = swp.x + swp.cx;
  7553.         rcl.yTop = swp.y + swp.cy;
  7554.         // calculate the size of the frame given the size of the client
  7555.         // only the size of the rect is considered
  7556.         WinCalcFrameRect( hwnd, &rcl, FALSE );
  7557.         WinSetWindowPos( hwnd,
  7558.                          HWND_TOP,
  7559.                          0,
  7560.                          0,
  7561.                          rcl.xRight-rcl.xLeft,
  7562.                          rcl.yTop-rcl.yBottom,
  7563.                          SWP_SIZE );
  7564.  
  7565.         /*┌──────────────────────────────────────────────────────────────┐
  7566.           │ Load dialogs (0,) 1 and 2                                    │
  7567.           └──────────────────────────────────────────────────────────────┘*/
  7568.         if (UCMData->bItemCreation) {
  7569.         /*┌──────────────┐
  7570.           │ >> PAGE 0 << │
  7571.           └──────────────┘*/
  7572.           hwndPage = WinLoadDlg(hwnd,
  7573.                                 hwnd,
  7574.                                 UCMenuNBP0DlgProc,
  7575.                                 UCMData->hModUCM,
  7576.                                 IDD_UCMNBP0,
  7577.                                 (PVOID)UCMData);
  7578.  
  7579.         /*┌───────────────┐
  7580.           │ Tab text      │
  7581.           └───────────────┘*/
  7582.           WinSendMsg(hwndNB,
  7583.                      BKM_SETTABTEXT,
  7584.                      (MPARAM)PageID0,
  7585.                      MPFROMP( nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_POSITION, 0 ) ) );
  7586.         /*┌───────────────┐
  7587.           │ Set page hwnd │
  7588.           └───────────────┘*/
  7589.           WinSendMsg(hwndNB,
  7590.                      BKM_SETPAGEWINDOWHWND,
  7591.                      (MPARAM)PageID0,
  7592.                      MPFROMHWND(hwndPage));
  7593.         } /* endif */
  7594.         WinSetOwner( hwndPage, hwndNB );
  7595.         /*┌──────────────┐
  7596.           │ >> PAGE 1 << │
  7597.           └──────────────┘*/
  7598.         hwndPage = WinLoadDlg(hwnd,
  7599.                               hwnd,
  7600.                               UCMenuNBP1DlgProc,
  7601.                               UCMData->hModUCM,
  7602.                               IDD_UCMNBP1,
  7603.                               (PVOID)UCMData);
  7604.  
  7605.         /*┌───────────────┐
  7606.           │ Tab text      │
  7607.           └───────────────┘*/
  7608.         WinSendMsg(hwndNB,
  7609.                    BKM_SETTABTEXT,
  7610.                    (MPARAM)PageID2,
  7611.                     MPFROMP( nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_GENERAL, 0 ) ) );
  7612.         /*┌───────────────┐
  7613.           │ Set page hwnd │
  7614.           └───────────────┘*/
  7615.         WinSendMsg(hwndNB,
  7616.                    BKM_SETPAGEWINDOWHWND,
  7617.                    (MPARAM)PageID2,
  7618.                    MPFROMHWND(hwndPage));
  7619.         WinSetOwner( hwndPage, hwndNB );
  7620.         /*┌──────────────┐
  7621.           │ >> PAGE 2 << │
  7622.           └──────────────┘*/
  7623.         hwndPage = WinLoadDlg(hwnd,
  7624.                               hwnd,
  7625.                               UCMenuNBP2DlgProc,
  7626.                               UCMData->hModUCM,
  7627.                               IDD_UCMNBP2,
  7628.                               (PVOID)UCMData);
  7629.         /*┌───────────────┐
  7630.           │ Tab text      │
  7631.           └───────────────┘*/
  7632.         WinSendMsg(hwndNB,
  7633.                    BKM_SETTABTEXT,
  7634.                    (MPARAM)PageID1,
  7635.                     MPFROMP( nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_ACTION, 0 ) ) );
  7636.         /*┌───────────────┐
  7637.           │ Set page hwnd │
  7638.           └───────────────┘*/
  7639.         WinSendMsg(hwndNB,
  7640.                    BKM_SETPAGEWINDOWHWND,
  7641.                    (MPARAM)PageID1,
  7642.                    MPFROMHWND(hwndPage));
  7643.         WinSetOwner( hwndPage, hwndNB );
  7644.         /*┌───────────────┐
  7645.           │ Set focus     │
  7646.           └───────────────┘*/
  7647.         if (UCMData->bItemCreation) {
  7648.            WinPostMsg( UCMData->hwndPage0, GETTING_FOCUS, 0L, 0L );
  7649.         } else {
  7650.            WinPostMsg( UCMData->hwndPage2, GETTING_FOCUS, 0L, 0L );
  7651.         } // endif
  7652.  
  7653.       } break;
  7654.  
  7655.     // (MAM) Added processing of OK/CANCEL buttons, simplified exit
  7656.     //       processing of notebook pages (all exit processing now
  7657.     //       done here instead of in each page dialog proc).
  7658.     case WM_COMMAND:
  7659.       switch (SHORT1FROMMP(mp1)) {
  7660.         case DID_CANCEL:
  7661.           WinDismissDlg(hwnd, DID_CANCEL);
  7662.           return 0;
  7663.         case DID_OK:
  7664.           {
  7665.             PUCMDATA UCMData;
  7666.             UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  7667.             if (UCMData->bItemCreation) {
  7668.               /* Create item.  Dismiss if no error. */
  7669.               if (UCMenuNBP0OK(hwnd))
  7670.                 WinDismissDlg(hwnd, DID_OK);
  7671.               return 0;
  7672.             }
  7673.             else {
  7674.               /* Do "OK" processing, then dismiss */
  7675.               UCMenuNBP1OK(UCMData->hwndPage1);
  7676.               UCMenuNBP2OK(UCMData->hwndPage2);
  7677.               WinDismissDlg(hwnd, DID_OK);  /* We are done */
  7678.               return 0;
  7679.             } /* endif */
  7680.           } /* OK case */
  7681.  
  7682.       } /* switch */
  7683.       break;
  7684.  
  7685.     case WM_CLOSE:
  7686.       // (MAM) Close from system menu is now CANCEL function
  7687.       WinDismissDlg(hwnd, DID_CANCEL);
  7688.       return 0;
  7689.  
  7690.     case WM_DESTROY:
  7691.      {
  7692.      /*┌────────────────────────────────────────────┐
  7693.        │ Dismiss the dialog and destroy the windows │
  7694.        └────────────────────────────────────────────┘*/
  7695.          PUCMDATA UCMData;
  7696.          UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  7697.  
  7698.          if (UCMData->bItemCreation) {
  7699.            WinDismissDlg(UCMData->hwndPage0, TRUE);
  7700.            WinDestroyWindow(UCMData->hwndPage0);
  7701.          } /* endif */
  7702.          WinDismissDlg(UCMData->hwndPage1, TRUE);
  7703.          WinDismissDlg(UCMData->hwndPage2, TRUE);
  7704.          WinDestroyWindow(UCMData->hwndPage1);
  7705.          WinDestroyWindow(UCMData->hwndPage2);
  7706.       }
  7707.       break;
  7708.  
  7709.     default:
  7710.       return WinDefDlgProc(hwnd, msg, mp1, mp2);
  7711.   } /* endswitch */
  7712.   return (MRESULT)0;
  7713. }
  7714. #endif
  7715.  
  7716. #if defined(UCMUI)
  7717. //----------------------------------------------------------------------------
  7718. // UCMenuNBP1DlgProc
  7719. //----------------------------------------------------------------------------
  7720. // :pfunction res=&IDF_PG1DLGPROC. name='UCMenuNBP1DlgProc' text='UCMenu settings notebook page 1 dialog procedure'.
  7721. // Dialog procedure of the page 1 of the ucmenu settings notebook
  7722. // :syntax name='UCMenuNBP1DlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  7723. // :fparams.
  7724. // :fparam name='hwnd' type='HWND' io='input' .
  7725. // Notebook page 1 window handle
  7726. // :fparam name='msg' type='ULONG' io='input' .
  7727. // Message
  7728. // :fparam name='mp1' type='MPARAM' io='input'.
  7729. // First parameter
  7730. // :fparam name='mp2' type='MPARAM' io='input'.
  7731. // Second parameter
  7732. // :freturns.
  7733. // :fparam name='mresult' type='MRESULT' io='return'.
  7734. // Return code of a PM message.
  7735. // :efparams.
  7736. // :remarks.
  7737. // :epfunction.
  7738. //----------------------------------------------------------------------------
  7739. MRESULT EXPENTRY  UCMenuNBP1DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  7740. {
  7741.   switch (msg) {
  7742.     case WM_INITDLG:
  7743.       {
  7744.         PUCMDATA UCMData = (PUCMDATA)mp2;
  7745.  
  7746.         WinSetWindowULong(hwnd, QWL_USER, (ULONG)UCMData);
  7747.         UCMData->hwndPage1 = hwnd;
  7748.         UCMenuNBP1Initialize(UCMData, hwnd);
  7749.       }
  7750.       break;
  7751.  
  7752. //  case WM_ACTIVATE:
  7753. //    if (SHORT1FROMMP(mp1)) {
  7754. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  7755. //                 (MPARAM)hwnd, (MPARAM)hwnd);
  7756. //    } else {
  7757. //      // clear active help window when this window is deactivated - this is
  7758. //      // necessary for message box help, etc. to work properly
  7759. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  7760. //                 NULLHANDLE, NULLHANDLE);
  7761. //    } /* endif */
  7762. //    return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  7763.  
  7764.     case GETTING_FOCUS:
  7765.        WinSetFocus( HWND_DESKTOP, WinWindowFromID( hwnd, IDC_UCMNBP1TITLE ) );
  7766.      break;
  7767.  
  7768.     case WM_COMMAND:
  7769.       switch (SHORT1FROMMP(mp1)) {
  7770.         case IDB_UCMNBP1UNDO:
  7771.              {
  7772.                 PUCMDATA UCMData;
  7773.                 UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  7774.                 UCMenuNBP1Initialize(UCMData, hwnd);
  7775.                 return (MRESULT)0;
  7776.              }
  7777.  
  7778.         // (MAM) removed OK and CANCEL processing...
  7779.  
  7780.         case IDB_UCMNBP1LOAD:
  7781.           /*┌─────────────────────────┐
  7782.             │ Load a bitmap           │
  7783.             └─────────────────────────┘*/
  7784.         {  FILEDLG FileDlg;
  7785.            PUCMDATA UCMData;
  7786.            MENUITEM mi;
  7787.            UCHAR    szPath[CCHMAXPATH];
  7788.            PSZ      pszIndex;
  7789.            UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  7790.            memset(&FileDlg, 0, sizeof(FileDlg));
  7791.  
  7792.            if ( ! UCMData->bItemCreation ) {
  7793.               WinSendMsg(UCMData->hwndTemp,
  7794.                          MM_QUERYITEM,
  7795.                          MPFROM2SHORT( UCMData->ContextID, TRUE ),
  7796.                          MPFROMP(&mi));
  7797.            }
  7798.  
  7799.            FileDlg.cbSize     = sizeof(FileDlg);
  7800.            FileDlg.fl         = FDS_OPEN_DIALOG | FDS_CENTER;
  7801.            FileDlg.pfnDlgProc = BitmapFileDlgProc;
  7802.            FileDlg.ulUser     = (ULONG) UCMData;
  7803.  
  7804.            if ( ! UCMData->bItemCreation && ITEM( &mi, pszBmp ) ) {
  7805.               strcpy((PSZ)(&(FileDlg.szFullFile)), (PSZ)(ITEM(&mi, pszBmp)));
  7806.            } else {
  7807.               szPath[CCHMAXPATH-1] = '\0';
  7808.               strncpy( szPath, UCMData->szBitmapPath, CCHMAXPATH );
  7809.               strncat( szPath, "*.bmp", CCHMAXPATH );
  7810.               strncpy( FileDlg.szFullFile, szPath, CCHMAXPATH );
  7811.            }
  7812.            WinFileDlg( HWND_DESKTOP, hwnd, &FileDlg );
  7813.  
  7814.  
  7815.            if ( FileDlg.lReturn == DID_OK ) {
  7816.               // -- UCMData->hBmpTemp has been updated by the subclassed  filedlgproc
  7817.               WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), TRUE );
  7818.               UCMenuNBP1UpdateBmp( hwnd, FileDlg.szFullFile );
  7819.               pszIndex = strrchr( FileDlg.szFullFile, '\\' );
  7820.               if ( pszIndex ) {
  7821.                  *( pszIndex + 1 ) = '\0';
  7822.               } /* endif */
  7823.               strncpy( UCMData->szBitmapPath, FileDlg.szFullFile, CCHMAXPATH );
  7824.            } // endif
  7825.         }
  7826.         break;
  7827.  
  7828.         case IDB_UCMNBP1EDIT :
  7829.         {
  7830.            PSZ pszTxt = MyMalloc( MAXPATHL );
  7831.            WinQueryDlgItemText(hwnd, IDC_UCMNBP1FILENAME, (LONG)MAXPATHL, pszTxt);
  7832.  
  7833.            UCMenuEditBmpFile( hwnd, pszTxt );
  7834.  
  7835.         }
  7836.         break;
  7837.  
  7838.  
  7839.         case IDB_UCMNBP1PREDEFINED :
  7840.         {
  7841.            ULONG ulResult;
  7842.            PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER );
  7843.  
  7844.            if ( !UCMData ) {
  7845.               return (MRESULT)FALSE;
  7846.            } // endif
  7847.  
  7848.            ulResult = WinDlgBox( HWND_DESKTOP,
  7849.                                  hwnd,
  7850.                                  ResBmpDlgProc,
  7851.                                  UCMData->hModUCM,
  7852.                                  IDD_RESBMP,
  7853.                                  (PVOID)UCMData );
  7854.            if ( ulResult && ( ulResult != DID_ERROR ) ){
  7855.               HBITMAP hbmp;
  7856.               HPS     hPS = WinGetPS( UCMData->hwndMenu );
  7857.               hbmp = (ULONG)GpiLoadBitmap( hPS,
  7858.                                            UCMData->hModBmp,
  7859.                                            UCMData->ulBmpTempId,
  7860.                                            0,
  7861.                                            0);
  7862.               WinReleasePS( hPS );
  7863.               if ( hbmp ) {
  7864.                  CHAR szBmpId[22];
  7865.                  sprintf( szBmpId, "%i", UCMData->ulBmpTempId );
  7866.                  UCMData->hBmpTemp = hbmp;
  7867.                  UCMData->bBmpTempFromFile = FALSE;
  7868.                  WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), FALSE );
  7869.  
  7870.                  UCMenuNBP1UpdateBmp( hwnd, szBmpId );
  7871.               } // endif
  7872.            } // endif
  7873.         }
  7874.         break;
  7875.  
  7876.         case IDB_UCMNBP1NOBMP :
  7877.         {
  7878.            PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER );
  7879.  
  7880.            if ( !UCMData ) {
  7881.               return (MRESULT)FALSE;
  7882.            } // endif
  7883.  
  7884.            UCMData->hBmpTemp = 0;
  7885.            UCMData->bBmpTempFromFile = FALSE;
  7886.            WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), FALSE );
  7887.  
  7888.            UCMenuNBP1UpdateBmp( hwnd, "" );
  7889.         }
  7890.         break;
  7891.  
  7892.         case IDB_UCMNBP1CREATE :
  7893.         {
  7894.            PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwnd, QWL_USER );
  7895.            WinDlgBox( HWND_DESKTOP,
  7896.                       hwnd,
  7897.                       UCMenuCreateBmpDlgProc,
  7898.                       UCMData->hModUCM,
  7899.                       IDD_UCMGETBMPNAME,
  7900.                       (PVOID)UCMData );
  7901.         }
  7902.         break;
  7903.  
  7904.       } // endswitch
  7905.       break;
  7906.  
  7907.     case UCMNBP1_NEWBMP:
  7908.     {
  7909.        PSZ pszFileName = (PSZ)mp1;
  7910.        PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER );
  7911.  
  7912.        HBITMAP hBmp = UCMenuLoadBitmap( pszFileName );
  7913.  
  7914.        if ( hBmp ) {
  7915.           UCMData->hBmpTemp = hBmp;
  7916.           UCMData->bBmpTempFromFile = TRUE;
  7917.           UCMenuNBP1UpdateBmp( hwnd, pszFileName );
  7918.        } // endif
  7919.        WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1LOAD ),   TRUE );
  7920.        WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1CREATE ), TRUE );
  7921.        WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ),   TRUE );
  7922.        WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1PREDEFINED ),   TRUE );
  7923.     } break;
  7924.  
  7925.     case WM_PAINT:
  7926.     { MPARAM rc;
  7927.       HPS    hPS;
  7928.       SWP    swp;
  7929.       RECTL  rcl;
  7930.       POINTL pt;
  7931.       BITMAPINFOHEADER BmpInfo;
  7932.       PUCMDATA UCMData;
  7933.       UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  7934.  
  7935.       rc = WinDefDlgProc(hwnd, msg, mp1, mp2);
  7936.  
  7937.       if ( UCMData->hBmpTemp ) {
  7938.         hPS = WinGetPS( hwnd );
  7939.         WinQueryWindowPos( WinWindowFromID( hwnd, IDC_UCMNBP1BITMAP ), &swp );
  7940.  
  7941.         GpiQueryBitmapParameters( UCMData->hBmpTemp, &BmpInfo );
  7942.         pt.x = (BmpInfo.cx > swp.cx ? swp.x : swp.x + (swp.cx - BmpInfo.cx)/2);
  7943.         pt.y = (BmpInfo.cy > swp.cy ? swp.y : swp.y + (swp.cy - BmpInfo.cy)/2);
  7944.         rcl.xLeft   = 0;
  7945.         rcl.yBottom = 0;
  7946.         rcl.xRight  = swp.cx;
  7947.         rcl.yTop    = swp.cy;
  7948.         WinDrawBitmap( hPS,
  7949.                        UCMData->hBmpTemp,
  7950.                        &rcl,
  7951.                        &pt,
  7952.                        0,
  7953.                        0,
  7954.                        DBM_NORMAL );
  7955.         WinReleasePS( hPS );
  7956.       } // endif
  7957.       return rc;
  7958.     }
  7959.  
  7960.     case WM_HELP:
  7961.       switch (SHORT1FROMMP(mp1)) {
  7962.       case IDB_UCMNBP1HELP:
  7963.          {
  7964.             PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER);
  7965.  
  7966.             UCMenuDisplayHelp( UCMData,
  7967.                        (USHORT)PANEL_ITEMBMP,
  7968.                        (USHORT)UCN_HLP_NB_BMP );
  7969.  
  7970.          }
  7971.          break;
  7972.       default:
  7973.          return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  7974.       } // endswitch
  7975.       break;
  7976.  
  7977.     default:
  7978.       return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  7979.  
  7980.   } // endswitch
  7981.  
  7982.   return (MRESULT)0;
  7983. }
  7984. #endif
  7985.  
  7986. #if defined(UCMUI)
  7987. //----------------------------------------------------------------------------
  7988. // UCMenuNBP1Initialize : Not for the user's doc
  7989. //----------------------------------------------------------------------------
  7990. // :pfunction res=&IDF_INITPG1. name='UCMenuNBP1Initialize' text='Initializes the page 1 of the settings notebook' .
  7991. // This function initializes the page 1 of the settings notebook
  7992. // :syntax name='UCMenuNBP1Initialize' params='UCMData, hwnd' return='-' .
  7993. // :fparams.
  7994. // :fparam name='UCMData' type='PUCMDATA' io='input' .
  7995. // Pointer to the UCMDATA structure
  7996. // :fparam name='hwnd' type='HWND' io='input' .
  7997. // Page 1 window handle.
  7998. // :freturns.
  7999. // :fparam name='-' type='VOID' io='-'.
  8000. // Nothing
  8001. // :efparams.
  8002. // :remarks.
  8003. // :related.
  8004. // :epfunction.
  8005. //----------------------------------------------------------------------------
  8006. VOID _Optlink UCMenuNBP1Initialize(PUCMDATA UCMData, HWND hwnd)
  8007. {
  8008.    if (UCMData->bItemCreation) {
  8009.      /*┌──────────────────────────────────────────────────────────────┐
  8010.        │ Item Creation : blank the fields                             │
  8011.        └──────────────────────────────────────────────────────────────┘*/
  8012.      RECTL rcl;
  8013.      SWP   swp;
  8014.      HPS   hPS = WinGetPS( hwnd );
  8015.  
  8016.      WinSetDlgItemText( hwnd, IDC_UCMNBP1TITLE, "" );
  8017.  
  8018.      UCMData->hBmpTemp = 0;
  8019.      UCMData->bBmpTempFromFile = FALSE;
  8020.      WinQueryWindowPos( WinWindowFromID( hwnd, IDC_UCMNBP1BITMAP ), &swp );
  8021.      rcl.xLeft   = swp.x;
  8022.      rcl.yBottom = swp.y;
  8023.      rcl.xRight  = swp.x + swp.cx;
  8024.      rcl.yTop    = swp.y + swp.cy;
  8025.      WinFillRect( hPS, &rcl, SYSCLR_DIALOGBACKGROUND );
  8026.      WinSetDlgItemText( hwnd, IDC_UCMNBP1FILENAME, 0 );
  8027.      WinReleasePS( hPS );
  8028.  
  8029.      WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), FALSE );
  8030.  
  8031.    } else {
  8032.      /*┌──────────────────────────────────────────────────────────────┐
  8033.        │ Editing : get the data from the item                         │
  8034.        └──────────────────────────────────────────────────────────────┘*/
  8035.      MENUITEM mi;
  8036.      PSZ      pszTxt;
  8037.      SWP      swp;
  8038.      RECTL    rcl;
  8039.      POINTL   pt;
  8040.      HPS      hPS = WinGetPS(hwnd);
  8041.      HWND     hwndUCM;
  8042.      BITMAPINFOHEADER BmpInfo;
  8043.      ULONG    ulSize;
  8044.  
  8045.      hwndUCM = UCMData->hwndTemp;
  8046.  
  8047.  
  8048.      memset(&mi, 0, sizeof(MENUITEM));
  8049.      /*┌─────────────────────────────┐
  8050.        │ Query item                  │
  8051.        └─────────────────────────────┘*/
  8052.      WinSendMsg(hwndUCM,
  8053.                 MM_QUERYITEM,
  8054.                 MPFROM2SHORT(UCMData->ContextID, TRUE),
  8055.                 MPFROMP(&mi));
  8056.  
  8057.      /*┌─────────────────────────────┐
  8058.        │ Query item text             │
  8059.        └─────────────────────────────┘*/
  8060.        if (mi.hItem && ITEM(&mi, pszText)) {
  8061.          ulSize = strlen(ITEM(&mi, pszText));
  8062.          pszTxt = MyMalloc(ulSize + 1);
  8063.          if (pszTxt) {
  8064.            strcpy(pszTxt, ITEM(&mi, pszText));
  8065.            WinSetDlgItemText(hwnd, IDC_UCMNBP1TITLE, pszTxt);
  8066.            MyFree(pszTxt);
  8067.          } else {
  8068.            WinSetDlgItemText(hwnd, IDC_UCMNBP1TITLE, "");
  8069.          } /* endif */
  8070.        } else {
  8071.          WinSetDlgItemText(hwnd, IDC_UCMNBP1TITLE, "");
  8072.        } /* endif */
  8073.  
  8074.      WinQueryWindowPos( WinWindowFromID( hwnd, IDC_UCMNBP1BITMAP ), &swp );
  8075.  
  8076.      rcl.xLeft   = swp.x;
  8077.      rcl.yBottom = swp.y;
  8078.      rcl.xRight  = swp.x + swp.cx;
  8079.      rcl.yTop    = swp.y + swp.cy;
  8080.      WinFillRect( hPS, &rcl, SYSCLR_DIALOGBACKGROUND );
  8081.  
  8082.      WinSetDlgItemText( hwnd, IDC_UCMNBP1FILENAME, "" );
  8083.  
  8084.      if ( mi.hItem && ITEM( &mi, hBmp ) ) {
  8085.      /*┌─────────────────────────────┐
  8086.        │ Query item bitmap           │
  8087.        └─────────────────────────────┘*/
  8088.  
  8089.        GpiQueryBitmapParameters( UCMData->hBmpTemp = ITEM(&mi, hBmp), &BmpInfo );
  8090.        pt.x = ( BmpInfo.cx > swp.cx ? swp.x : swp.x + ( swp.cx - BmpInfo.cx )/2 );
  8091.        pt.y = ( BmpInfo.cy > swp.cy ? swp.y : swp.y + ( swp.cy - BmpInfo.cy )/2 );
  8092.        rcl.xLeft   = 0;
  8093.        rcl.yBottom = 0;
  8094.        rcl.xRight  = swp.cx;
  8095.        rcl.yTop    = swp.cy;
  8096.        WinDrawBitmap( hPS,
  8097.                       UCMData->hBmpTemp = ITEM( &mi, hBmp ),
  8098.                       &rcl,
  8099.                       &pt,
  8100.                       0,
  8101.                       0,
  8102.                       DBM_NORMAL );
  8103.         WinSetDlgItemText( hwnd, IDC_UCMNBP1FILENAME, ITEM( &mi, pszBmp ) );
  8104.         if ( ITEM( &mi, ulFlags ) & UCMI_BMPFROMFILE ){
  8105.            UCMData->bBmpTempFromFile = TRUE;
  8106.            WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), TRUE );
  8107.         } else {
  8108.            UCMData->bBmpTempFromFile = FALSE;
  8109.            WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), FALSE );
  8110.         } // endif
  8111.      } else {
  8112.         UCMData->hBmpTemp = 0;
  8113.         UCMData->bBmpTempFromFile = FALSE;
  8114.         WinEnableWindow( WinWindowFromID( hwnd, IDB_UCMNBP1EDIT ), FALSE );
  8115.      } // endif
  8116.  
  8117.      WinReleasePS( hPS );
  8118.  
  8119.  
  8120.    } // endif
  8121. }
  8122. #endif
  8123.  
  8124. #if defined(UCMUI)
  8125. //----------------------------------------------------------------------------
  8126. // UCMenuNBP2DlgProc
  8127. //----------------------------------------------------------------------------
  8128. // :pfunction res=&IDF_PG2DLGPROC. name='UCMenuNBP2DlgProc' text='UCMenu settings notebook page 2 dialog procedure'.
  8129. // Dialog procedure of the page 2 of the ucmenu settings notebook
  8130. // :syntax name='UCMenuNBP2DlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  8131. // :fparams.
  8132. // :fparam name='hwnd' type='HWND' io='input' .
  8133. // Notebook page 2 window handle
  8134. // :fparam name='msg' type='ULONG' io='input' .
  8135. // Message
  8136. // :fparam name='mp1' type='MPARAM' io='input'.
  8137. // First parameter
  8138. // :fparam name='mp2' type='MPARAM' io='input'.
  8139. // Second parameter
  8140. // :freturns.
  8141. // :fparam name='mresult' type='MRESULT' io='return'.
  8142. // Return code of a PM message.
  8143. // :efparams.
  8144. // :remarks.
  8145. // :epfunction.
  8146. //----------------------------------------------------------------------------
  8147. MRESULT EXPENTRY  UCMenuNBP2DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  8148. {
  8149.   switch (msg) {
  8150.     case WM_INITDLG:
  8151.       {
  8152.         PUCMDATA UCMData = (PUCMDATA)mp2;
  8153.  
  8154.         WinSetWindowULong(hwnd, QWL_USER, (ULONG)UCMData);
  8155.  
  8156.         UCMData->hwndPage2 = hwnd;
  8157.        /*┌──────────────────────────────────────────────────────────────┐
  8158.          │ Set maximum length of the fields                             │
  8159.          └──────────────────────────────────────────────────────────────┘*/
  8160.         WinSendDlgItemMsg(hwnd,
  8161.                           IDC_UCMNBP2FLIST,
  8162.                           EM_SETTEXTLIMIT,
  8163.                           MPFROMSHORT(255),
  8164.                           (MPARAM)0);
  8165.         WinSendDlgItemMsg(hwnd,
  8166.                           IDC_UCMNBP2PARAMS,
  8167.                           EM_SETTEXTLIMIT,
  8168.                           MPFROMSHORT(255),
  8169.                           (MPARAM)0);
  8170.         UCMenuNBP2Initialize(UCMData, hwnd);
  8171.       } break;
  8172.  
  8173. //  case WM_ACTIVATE:
  8174. //    if (SHORT1FROMMP(mp1)) {
  8175. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  8176. //                 (MPARAM)hwnd, (MPARAM)hwnd);
  8177. //    } else {
  8178. //      // clear active help window when this window is deactivated - this is
  8179. //      // necessary for message box help, etc. to work properly
  8180. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  8181. //                 NULLHANDLE, NULLHANDLE);
  8182. //    } /* endif */
  8183. //    return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8184.  
  8185.     case GETTING_FOCUS:
  8186.        WinSetFocus( HWND_DESKTOP, WinWindowFromID( hwnd, IDC_UCMNBP2FLIST ) );
  8187.      break;
  8188.  
  8189.     case WM_CONTROL:
  8190.        {
  8191.           switch ( SHORT1FROMMP( mp1 ) ) {
  8192.           case IDC_UCMNBP2FLIST:
  8193.              switch ( SHORT2FROMMP( mp1 ) ){
  8194.              case CBN_LBSELECT:
  8195.              {
  8196.                 SHORT sIndex;
  8197.                 CHAR pszDesc[MAXDESCLEN];
  8198.                 sIndex = (USHORT)WinSendMsg( HWNDFROMMP( mp2 ), LM_QUERYSELECTION, MPFROMSHORT( LIT_FIRST ), (MPARAM)0 );
  8199.                 sIndex = (USHORT)WinSendDlgItemMsg(hwnd,
  8200.                                                    IDC_UCMNBP2DLIST,
  8201.                                                    LM_QUERYITEMTEXT,
  8202.                                                    MPFROM2SHORT( sIndex, MAXDESCLEN ),
  8203.                                                    MPFROMP( pszDesc ) );
  8204.                 WinSetDlgItemText( hwnd, IDC_UCMNBP2DESC, pszDesc );
  8205.                 return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8206.              }
  8207.              default:
  8208.                return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8209.                break;
  8210.              } // endswitch
  8211.           default:
  8212.              return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8213.           } // endswitch
  8214.  
  8215.        }
  8216.      break;
  8217.  
  8218.     case UCMENU_ACTIONSINSERTED:
  8219.       // -- This message is posted by the owner to let me know that
  8220.       // -- the list of actions was filled. What I have to do is hilite the
  8221.       // -- current action in the list or, if it's not in it, add it to the
  8222.       // -- list and highlight it.
  8223.       { MENUITEM mi;
  8224.         PSZ      pszTxt, pszParams;
  8225.         CHAR     pszDesc[MAXDESCLEN];
  8226.         PUCMDATA UCMData;
  8227.  
  8228.         WinShowWindow( WinWindowFromID( hwnd, IDC_UCMNBP2LOADING ), FALSE );
  8229.  
  8230.         UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  8231.  
  8232.         memset(&mi, 0, sizeof(MENUITEM));
  8233.  
  8234.         if (!(UCMData->bItemCreation)) {
  8235.            //-- Query item
  8236.            WinSendMsg(UCMData->hwndTemp,
  8237.                       MM_QUERYITEM,
  8238.                       MPFROM2SHORT(UCMData->ContextID, TRUE),
  8239.                       MPFROMP(&mi));
  8240.         }
  8241.  
  8242.         if (mi.hItem) {
  8243.           pszTxt = ITEM(&mi, pszAction);
  8244.           pszParams = ITEM(&mi, pszParameters);
  8245.           if (pszTxt) {
  8246.             SHORT  sIndex;
  8247.  
  8248.             if (pszParams) {
  8249.               WinSetDlgItemText(hwnd, IDC_UCMNBP2PARAMS, pszParams);
  8250.             } else {
  8251.               WinSetDlgItemText(hwnd, IDC_UCMNBP2PARAMS, "");
  8252.             } /* endif */
  8253.  
  8254.             sIndex = (USHORT)WinSendDlgItemMsg(hwnd,
  8255.                                                IDC_UCMNBP2FLIST,
  8256.                                                LM_SEARCHSTRING,
  8257.                                                MPFROM2SHORT(LSS_CASESENSITIVE, LIT_FIRST),
  8258.                                                MPFROMP(pszTxt));
  8259.             if (sIndex==LIT_NONE || sIndex==LIT_ERROR) {
  8260.                //-- Add it to the list
  8261.                sIndex = (USHORT) WinSendDlgItemMsg(hwnd,
  8262.                                                    IDC_UCMNBP2FLIST,
  8263.                                                    LM_INSERTITEM,
  8264.                                                    (MPARAM)LIT_END,
  8265.                                                    MPFROMP(pszTxt));
  8266.                WinSendDlgItemMsg(hwnd,
  8267.                                  IDC_UCMNBP2DLIST,
  8268.                                  LM_INSERTITEM,
  8269.                                  (MPARAM)LIT_END,
  8270.                                  MPFROMP(""));
  8271.                WinSetDlgItemText(hwnd, IDC_UCMNBP2DESC, "");
  8272.             } else {
  8273.                WinSendDlgItemMsg(hwnd,
  8274.                                  IDC_UCMNBP2DLIST,
  8275.                                  LM_QUERYITEMTEXT,
  8276.                                  MPFROM2SHORT( sIndex, MAXDESCLEN ),
  8277.                                  MPFROMP( pszDesc ) );
  8278.                WinSetDlgItemText( hwnd, IDC_UCMNBP2DESC, pszDesc );
  8279.             } // endif
  8280.             //-- Select it
  8281.             WinSendDlgItemMsg(hwnd,
  8282.                               IDC_UCMNBP2FLIST,
  8283.                               LM_SELECTITEM,
  8284.                               MPFROMSHORT(sIndex),
  8285.                               MPFROMSHORT(TRUE));
  8286.           } else {
  8287.             WinSetDlgItemText(hwnd, IDC_UCMNBP2PARAMS, "");
  8288.           } /* endif */
  8289.         } /* endif */
  8290.       } break;
  8291.  
  8292.     case WM_COMMAND:
  8293.       switch (SHORT1FROMMP(mp1)) {
  8294.         case IDB_UCMNBP2UNDO:
  8295.              {
  8296.                 PUCMDATA UCMData;
  8297.                 UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  8298.                 // -- Empty the functions list because it will be filled again
  8299.                 WinSendDlgItemMsg(hwnd,
  8300.                                   IDC_UCMNBP2FLIST,
  8301.                                   LM_DELETEALL,
  8302.                                   (MPARAM)0,
  8303.                                   (MPARAM)0);
  8304.                 WinSendDlgItemMsg(hwnd,
  8305.                                   IDC_UCMNBP2DLIST,
  8306.                                   LM_DELETEALL,
  8307.                                   (MPARAM)0,
  8308.                                   (MPARAM)0);
  8309.                 UCMenuNBP2Initialize(UCMData, hwnd);
  8310.                 return(MRESULT)0;
  8311.              }
  8312.  
  8313.         // (MAM) removed OK and CANCEL processing...
  8314.  
  8315.       } /* endswitch */
  8316.       break;
  8317.  
  8318.     case WM_HELP:
  8319.       switch (SHORT1FROMMP(mp1)) {
  8320.       case IDB_UCMNBP2HELP:
  8321.          {
  8322.             PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER);
  8323.             UCMenuDisplayHelp( UCMData,
  8324.                        (USHORT)PANEL_ITEMACTION,
  8325.                        (USHORT)UCN_HLP_NB_ACTION);
  8326.          }
  8327.          break;
  8328.       default:
  8329.         return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8330.         break;
  8331.       } // endswitch
  8332.       break;
  8333.  
  8334.     default:
  8335.       return WinDefDlgProc(hwnd, msg, mp1, mp2);
  8336.  
  8337.   } /* endswitch */
  8338.   return (MRESULT)0;
  8339. }
  8340. #endif
  8341.  
  8342. #if defined(UCMUI)
  8343. //----------------------------------------------------------------------------
  8344. // UCMenuNBP2Initialize : Not for the user's doc
  8345. //----------------------------------------------------------------------------
  8346. // :pfunction res=&IDF_INITPG2. name='UCMenuNBP2Initialize' text='Initializes the page 2 of the settings notebook' .
  8347. // This function initializes the page2  of the settings notebook
  8348. // :syntax name='UCMenuNBP2Initialize' params='UCMData, hwnd' return='-' .
  8349. // :fparams.
  8350. // :fparam name='UCMData' type='PUCMDATA' io='input' .
  8351. // Pointer to the UCMDATA structure
  8352. // :fparam name='hwnd' type='HWND' io='input' .
  8353. // Page 2 window handle.
  8354. // :freturns.
  8355. // :fparam name='-' type='VOID' io='-'.
  8356. // Nothing
  8357. // :efparams.
  8358. // :remarks.
  8359. // :related.
  8360. // :epfunction.
  8361. //----------------------------------------------------------------------------
  8362. VOID  _Optlink UCMenuNBP2Initialize(PUCMDATA UCMData, HWND hwnd)
  8363. {
  8364.  
  8365.    WinSetDlgItemText(hwnd, IDC_UCMNBP2FLIST, "");
  8366.    WinSetDlgItemText(hwnd, IDC_UCMNBP2PARAMS, "");
  8367.    WinSetDlgItemText(hwnd, IDC_UCMNBP2DESC, "");
  8368.    WinShowWindow( WinWindowFromID( hwnd, IDC_UCMNBP2LOADING ), TRUE );
  8369.  
  8370.  
  8371.    /*┌──────────────────────────────────────────────────────────────┐
  8372.      │ Add an entry in the list of actions : ExecuteProgram.        │
  8373.      │ It's an internal action.                                     │
  8374.      └──────────────────────────────────────────────────────────────┘*/
  8375.    if ( !( UCMData->Style & UCS_NODEFAULTACTION ) ){
  8376.       WinSendDlgItemMsg(hwnd,
  8377.                         IDC_UCMNBP2FLIST,
  8378.                         LM_INSERTITEM,
  8379.                         (MPARAM)LIT_FIRST,
  8380.                         MPFROMP(&UCM_ACTION_EXEC));
  8381.       //-- Add the corresponding entry in the listbox of description
  8382.       //-- This listbox is not displayed, just used to store the descriptions
  8383.       WinSendDlgItemMsg(hwnd,
  8384.                         IDC_UCMNBP2DLIST,
  8385.                         LM_INSERTITEM,
  8386.                         (MPARAM)LIT_FIRST,
  8387.                         MPFROMP( nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_DESCEXEC, 0 ) ) );
  8388.    } // endif
  8389.  
  8390.    //-- It's better to change the way we fill the list. Now we post a message to the
  8391.    //-- owner to let him know he can fill in the list. Before, it had to be synchronous
  8392.    //-- Now, the owner can query its internal list (call an EPM macro) and fill the
  8393.    //-- listbox when he's ready
  8394.    WinSendMsg( WinQueryWindow(UCMData->hwndTemp, QW_OWNER),
  8395.                WM_CONTROL,
  8396.                MPFROM2SHORT( WinQueryWindowUShort( UCMData->hwndTemp, QWS_ID ),
  8397.                              UCN_QRYACTIONLIST ),
  8398.                MPFROMHWND( UCMData->hwndTemp ) );
  8399. }
  8400. #endif
  8401.  
  8402. #if defined(UCMUI)
  8403. //----------------------------------------------------------------------------
  8404. // UCMenuNBP0DlgProc
  8405. //----------------------------------------------------------------------------
  8406. // :pfunction res=&IDF_PG0DLGPROC. name='UCMenuNBP0DlgProc' text='UCMenu settings notebook page 0 dialog procedure'.
  8407. // Dialog procedure of the page 0 of the ucmenu settings notebook
  8408. // :syntax name='UCMenuNBP0DlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  8409. // :fparams.
  8410. // :fparam name='hwnd' type='HWND' io='input' .
  8411. // Notebook page 0 window handle
  8412. // :fparam name='msg' type='ULONG' io='input' .
  8413. // Message
  8414. // :fparam name='mp1' type='MPARAM' io='input'.
  8415. // First parameter
  8416. // :fparam name='mp2' type='MPARAM' io='input'.
  8417. // Second parameter
  8418. // :freturns.
  8419. // :fparam name='mresult' type='MRESULT' io='return'.
  8420. // Return code of a PM message.
  8421. // :efparams.
  8422. // :remarks.
  8423. // :epfunction.
  8424. //----------------------------------------------------------------------------
  8425. MRESULT EXPENTRY  UCMenuNBP0DlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  8426. {
  8427.   switch (msg) {
  8428.     case WM_INITDLG:
  8429.       {
  8430.         PUCMDATA UCMData = (PUCMDATA)mp2;
  8431.  
  8432.         WinSetWindowULong(hwnd, QWL_USER, (ULONG)UCMData);
  8433.         UCMData->hwndPage0 = hwnd;
  8434.         UCMenuNBP0Initialize(UCMData, hwnd);
  8435.       }
  8436.       break;
  8437.  
  8438. //  case WM_ACTIVATE:
  8439. //    if (SHORT1FROMMP(mp1)) {
  8440. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  8441. //                 (MPARAM)hwnd, (MPARAM)hwnd);
  8442. //    } else {
  8443. //      // clear active help window when this window is deactivated - this is
  8444. //      // necessary for message box help, etc. to work properly
  8445. //      WinSendMsg(WinQueryHelpInstance(hwnd), HM_SET_ACTIVE_WINDOW,
  8446. //                 NULLHANDLE, NULLHANDLE);
  8447. //    } /* endif */
  8448. //    return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8449.  
  8450.     case GETTING_FOCUS:
  8451.        WinSetFocus( HWND_DESKTOP, WinWindowFromID( hwnd, IDC_UCMNBP0END ) );
  8452.      break;
  8453.  
  8454.     case WM_COMMAND:
  8455.       switch (SHORT1FROMMP(mp1)) {
  8456.         case IDB_UCMNBP0UNDO:
  8457.              {
  8458.                 PUCMDATA UCMData;
  8459.                 UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  8460.                 UCMenuNBP0Initialize(UCMData, hwnd);
  8461.              }
  8462.              break;
  8463.  
  8464.         // (MAM) removed OK and CANCEL processing
  8465.  
  8466.       } /* endswitch */
  8467.       break;
  8468.  
  8469.     case WM_HELP:
  8470.       switch (SHORT1FROMMP(mp1)) {
  8471.       case IDB_UCMNBP0HELP:
  8472.          {
  8473.             PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER);
  8474.             UCMenuDisplayHelp( UCMData,
  8475.                        (USHORT)PANEL_ITEMPOS,
  8476.                        (USHORT) UCN_HLP_NB_CREATE);
  8477.          }
  8478.          break;
  8479.       default:
  8480.         return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8481.         break;
  8482.       } // endswitch
  8483.       break;
  8484.  
  8485.     default:
  8486.       return WinDefDlgProc(hwnd, msg, mp1, mp2);
  8487.  
  8488.   } // endswitch
  8489.   return (MRESULT)0;
  8490. }
  8491. #endif
  8492.  
  8493. #if defined(UCMUI)
  8494. //----------------------------------------------------------------------------
  8495. // UCMenuNBP0Initialize : Not for the user's doc
  8496. //----------------------------------------------------------------------------
  8497. // :pfunction res=&IDF_INITPG0. name='UCMenuNBP0Initialize' text='Initializes the page 0 of the settings notebook' .
  8498. // This function initializes the page 0 of the settings notebook
  8499. // :syntax name='UCMenuNBP0Initialize' params='UCMData, hwnd' return='-' .
  8500. // :fparams.
  8501. // :fparam name='UCMData' type='PUCMDATA' io='input' .
  8502. // Pointer to the UCMDATA structure
  8503. // :fparam name='hwnd' type='HWND' io='input' .
  8504. // Page 0 window handle.
  8505. // :freturns.
  8506. // :fparam name='-' type='VOID' io='-'.
  8507. // Nothing
  8508. // :efparams.
  8509. // :remarks.
  8510. // :related.
  8511. // :epfunction.
  8512. //----------------------------------------------------------------------------
  8513.  
  8514. VOID  _Optlink UCMenuNBP0Initialize(PUCMDATA UCMData, HWND hwnd)
  8515. {
  8516.    if (!(UCMData->ContextID)) {
  8517.      /*┌──────────────────────────────────────────────────────────────┐
  8518.        │ No context ID means no item is selected. So the only place   │
  8519.        │ we can insert the item is the end. We don't need the 2       │
  8520.        │ buttons : we hide them.                                      │
  8521.        └──────────────────────────────────────────────────────────────┘*/
  8522.      WinShowWindow(WinWindowFromID(hwnd, IDC_UCMNBP0AFTER), FALSE);
  8523.      WinShowWindow(WinWindowFromID(hwnd, IDC_UCMNBP0BEFORE), FALSE);
  8524.    } /* endif */
  8525.    WinSendMsg(WinWindowFromID(hwnd, IDC_UCMNBP0END), BM_SETCHECK, (MPARAM)1, (MPARAM)0);
  8526.    WinSendMsg(WinWindowFromID(hwnd, IDC_UCMNBP0REGULAR), BM_SETCHECK, (MPARAM)1, (MPARAM)0);
  8527. }
  8528. #endif
  8529.  
  8530. #if defined(UCMUI)
  8531. //----------------------------------------------------------------------------
  8532. // UCMenuNBP1OK : Not for the user's doc
  8533. //----------------------------------------------------------------------------
  8534. // :pfunction res=&IDF_NBPG1OK. name='UCMenuNBP1OK' text='Processes the OK button for the page 1' .
  8535. // This function processes the OK button for the page 1 of the settings notebook
  8536. // :syntax name='UCMenuNBP1OK' params='hwnd' return='-' .
  8537. // :fparams.
  8538. // :fparam name='hwnd' type='HWND' io='input' .
  8539. // Page 1 window handle.
  8540. // :freturns.
  8541. // :fparam name='-' type='VOID' io='-'.
  8542. // Nothing
  8543. // :efparams.
  8544. // :remarks.
  8545. // :related.
  8546. // :epfunction.
  8547. //----------------------------------------------------------------------------
  8548. VOID  _Optlink UCMenuNBP1OK(HWND hwnd)
  8549. { MENUITEM mi;
  8550.   ULONG ulLen;
  8551.   PSZ   pszTitle;
  8552.   PUCMDATA UCMData;
  8553.  
  8554.   UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  8555.  
  8556.   /*┌──────────────────────┐
  8557.     │ Query the item data  │
  8558.     └──────────────────────┘*/
  8559.   memset(&mi, 0, sizeof(MENUITEM));
  8560.   WinSendMsg(UCMData->hwndCMOrig,
  8561.              MM_QUERYITEM,
  8562.              MPFROM2SHORT(UCMData->ContextID, TRUE),
  8563.              MPFROMP(&mi));
  8564.  
  8565.   /*┌──────────────────────┐
  8566.     │ Query the text       │
  8567.     └──────────────────────┘*/
  8568.   ulLen = WinQueryDlgItemTextLength(hwnd, IDC_UCMNBP1TITLE);
  8569.   if (ulLen) {
  8570.     pszTitle = MyMalloc(ulLen+1);
  8571.     if (pszTitle) {
  8572.       WinQueryDlgItemText(hwnd,
  8573.                           IDC_UCMNBP1TITLE,
  8574.                           ulLen+1,
  8575.                           pszTitle);
  8576.       /*┌──────────────────────┐
  8577.         │ Set the item text    │
  8578.         └──────────────────────┘*/
  8579.       if (mi.hItem) {
  8580.          if ( !ITEM(&mi,pszText) || strcmp(ITEM(&mi,pszText),pszTitle) ) {
  8581.             WinSendMsg( WinQueryWindow(UCMData->hwndTemp, QW_OWNER),
  8582.                     WM_CONTROL,
  8583.                     MPFROM2SHORT( WinQueryWindowUShort( UCMData->hwndTemp, QWS_ID ), UCN_TEXT ),
  8584.                     MPFROMSHORT( mi.id ) );
  8585.          } // endif
  8586.  
  8587.         if (ITEM(&mi, pszText)) {
  8588.           PSZ OldText = ITEM(&mi, pszText);
  8589.           PSZ StrPtr;
  8590.           if(StrPtr=strstr(OldText, "~")) {
  8591.              RemoveAccelItem(UCMData, StrPtr[1]);
  8592.           }
  8593.           MyFree(ITEM(&mi, pszText));
  8594.         }
  8595.  
  8596.         ITEM(&mi, pszText) = pszTitle;
  8597.         if(pszTitle && pszTitle[0]){
  8598.            PSZ StrPtr;
  8599.            if(StrPtr = strstr(pszTitle, "~")) {
  8600.               AddAccelItem(UCMData, StrPtr[1], UCMData->ContextID);
  8601.            }
  8602.         }
  8603.       } // endif
  8604.       //-- don't free pszTitle !
  8605.     } // endif
  8606.   } else {
  8607.       if (mi.hItem) {
  8608.         if (ITEM(&mi, pszText)) {
  8609.           PSZ OldText = ITEM(&mi, pszText);
  8610.           PSZ StrPtr;
  8611.           if(StrPtr=strstr(OldText, "~")) {
  8612.              RemoveAccelItem(UCMData, StrPtr[1]);
  8613.           }
  8614.           MyFree(ITEM(&mi, pszText));
  8615.         }
  8616.         ITEM(&mi, pszText) = 0;
  8617.      } // endif mi.hItem
  8618.   } // endif ulLen
  8619.  
  8620.   /*┌──────────────────────┐
  8621.     │ Go for the bitmap now│
  8622.     └──────────────────────┘*/
  8623.  
  8624.   /*┌────────────────────────────────────────┐
  8625.     │ Is there a filename set in the dialog ?│
  8626.     │ No means no bitmap is requested        │
  8627.     └────────────────────────────────────────┘*/
  8628.   ulLen = WinQueryDlgItemTextLength(hwnd, IDC_UCMNBP1FILENAME);
  8629.   if (ulLen) {
  8630.     PSZ pszBitmap = MyMalloc(ulLen+1);
  8631.  
  8632.     if (pszBitmap) {
  8633.       WinQueryDlgItemText(hwnd,
  8634.                           IDC_UCMNBP1FILENAME,
  8635.                           ulLen+1,
  8636.                           pszBitmap);
  8637.       if (ITEM(&mi, pszBmp)) {
  8638.          MyFree(ITEM(&mi, pszBmp));
  8639.       } // endif
  8640.       ITEM(&mi, pszBmp) = pszBitmap;
  8641.     } // endif
  8642.  
  8643.     if (ITEM(&mi,hBmp)!=UCMData->hBmpTemp) {
  8644.        WinSendMsg( WinQueryWindow( UCMData->hwndTemp, QW_OWNER ),
  8645.                    WM_CONTROL,
  8646.                    MPFROM2SHORT( WinQueryWindowUShort( UCMData->hwndTemp, QWS_ID ), UCN_BITMAP ),
  8647.                    MPFROMSHORT( mi.id) );
  8648.     } // endif
  8649.  
  8650.     ITEM(&mi, hBmp)   =  UCMData->hBmpTemp;
  8651.     if ( UCMData->bBmpTempFromFile ){
  8652.        ITEM( &mi, ulFlags ) |= UCMI_BMPFROMFILE;
  8653.     } else {
  8654.        ITEM( &mi, ulFlags ) &= ~UCMI_BMPFROMFILE;
  8655.     } // endif
  8656.   } else {
  8657.       if (ITEM(&mi, pszBmp)) {
  8658.          MyFree(ITEM(&mi, pszBmp));
  8659.       } // endif
  8660.       ITEM(&mi, pszBmp) = 0;
  8661.  
  8662.     if (ITEM(&mi,hBmp)!=UCMData->hBmpTemp) {
  8663.        WinSendMsg( WinQueryWindow( UCMData->hwndTemp, QW_OWNER ),
  8664.                    WM_CONTROL,
  8665.                    MPFROM2SHORT( WinQueryWindowUShort( UCMData->hwndTemp, QWS_ID ), UCN_BITMAP ),
  8666.                    MPFROMSHORT( mi.id) );
  8667.     } // endif
  8668.  
  8669.     ITEM(&mi, hBmp)   =  0;
  8670.     if ( UCMData->bBmpTempFromFile ){
  8671.        ITEM( &mi, ulFlags ) |= UCMI_BMPFROMFILE;
  8672.     } else {
  8673.        ITEM( &mi, ulFlags ) &= ~UCMI_BMPFROMFILE;
  8674.     } // endif
  8675.   } // endif
  8676.   /*┌──────────────────────┐
  8677.     │ Set the item back    │
  8678.     └──────────────────────┘*/
  8679.   WinSendMsg(UCMData->hwndCMOrig,
  8680.              MM_SETITEM,
  8681.              MPFROM2SHORT(0, TRUE),
  8682.              MPFROMP(&mi));
  8683. }
  8684. #endif
  8685.  
  8686. #if defined(UCMUI)
  8687. //----------------------------------------------------------------------------
  8688. // UCMenuNBP2OK : Not for the user's doc
  8689. //----------------------------------------------------------------------------
  8690. // :pfunction res=&IDF_NBPG2OK. name='UCMenuNBP2OK' text='Processes the OK button for the page 2' .
  8691. // This function processes the OK button for the page 2 of the settings notebook
  8692. // :syntax name='UCMenuNBP2OK' params='hwnd' return='-' .
  8693. // :fparams.
  8694. // :fparam name='hwnd' type='HWND' io='input' .
  8695. // Page 2 window handle.
  8696. // :freturns.
  8697. // :fparam name='-' type='VOID' io='-'.
  8698. // Nothing
  8699. // :efparams.
  8700. // :remarks.
  8701. // :related.
  8702. // :epfunction.
  8703. //----------------------------------------------------------------------------
  8704. VOID  _Optlink UCMenuNBP2OK(HWND hwnd)
  8705. {
  8706.   PSZ      pszFunction, pszParams;
  8707.   MENUITEM mi;
  8708.   ULONG    ulLen1, ulLen2;
  8709.   PUCMDATA UCMData;
  8710.  
  8711.   UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  8712.  
  8713.   /*┌──────────────────────────────────────────────────────────────┐
  8714.     │ We query the function selected by the user and the params    │
  8715.     └──────────────────────────────────────────────────────────────┘*/
  8716.   ulLen1 = WinQueryDlgItemTextLength(hwnd, IDC_UCMNBP2FLIST) + 1;
  8717.   pszFunction = MyMalloc(ulLen1);
  8718.   ulLen2 = WinQueryDlgItemTextLength(hwnd, IDC_UCMNBP2PARAMS) + 1;
  8719.   pszParams = MyMalloc(ulLen2);
  8720.   if (pszFunction) {
  8721.     WinQueryDlgItemText(hwnd,
  8722.                         IDC_UCMNBP2FLIST,
  8723.                         ulLen1,
  8724.                         pszFunction);
  8725.     if (pszParams) {
  8726.       WinQueryDlgItemText(hwnd,
  8727.                           IDC_UCMNBP2PARAMS,
  8728.                           ulLen2,
  8729.                           pszParams);
  8730.     } /* endif */
  8731.     memset(&mi, 0, sizeof(MENUITEM));
  8732.     //-- Query item
  8733.     WinSendMsg(UCMData->hwndCMOrig,
  8734.                MM_QUERYITEM,
  8735.                MPFROM2SHORT(UCMData->ContextID, TRUE),
  8736.                MPFROMP(&mi));
  8737.  
  8738.     if ( !ITEM(&mi,pszAction) || strcmp(ITEM(&mi,pszAction),pszFunction) ) {
  8739.        WinSendMsg( WinQueryWindow(UCMData->hwndTemp, QW_OWNER),
  8740.                WM_CONTROL,
  8741.                MPFROM2SHORT( WinQueryWindowUShort( UCMData->hwndTemp, QWS_ID ), UCN_ACTION ),
  8742.                MPFROMSHORT( mi.id ) );
  8743.     } // endif
  8744.  
  8745.     if (ITEM(&mi, pszAction)){
  8746.        MyFree (ITEM(&mi, pszAction));
  8747.     }
  8748.     if (ITEM(&mi, pszParameters)){
  8749.        MyFree (ITEM(&mi, pszParameters));
  8750.     }
  8751.  
  8752.     ITEM(&mi, pszAction) = pszFunction;
  8753.     ITEM(&mi, pszParameters) = pszParams;
  8754.     WinSendMsg(UCMData->hwndCMOrig,
  8755.                MM_SETITEM,
  8756.                MPFROM2SHORT(0, TRUE),
  8757.                MPFROMP(&mi));
  8758.   } // endif
  8759. }
  8760. #endif
  8761.  
  8762. #if defined(UCMUI)
  8763. //----------------------------------------------------------------------------
  8764. // UCMenuStyleDlgProc
  8765. //----------------------------------------------------------------------------
  8766. // :pfunction res=&IDF_STYLEDLGPROC. name='UCMenuStyleDlgProc' text='Style dialog procedure'.
  8767. // Dialog procedure of the style dialog
  8768. // :syntax name='UCMenuStyleDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  8769. // :fparams.
  8770. // :fparam name='hwnd' type='HWND' io='input' .
  8771. // Style dialog window handle
  8772. // :fparam name='msg' type='ULONG' io='input' .
  8773. // Message
  8774. // :fparam name='mp1' type='MPARAM' io='input'.
  8775. // First parameter
  8776. // :fparam name='mp2' type='MPARAM' io='input'.
  8777. // Second parameter
  8778. // :freturns.
  8779. // :fparam name='mresult' type='MRESULT' io='return'.
  8780. // Return code of a PM message.
  8781. // :efparams.
  8782. // :remarks.
  8783. // :epfunction.
  8784. //----------------------------------------------------------------------------
  8785. MRESULT EXPENTRY  UCMenuStyleDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  8786. {
  8787.   switch (msg) {
  8788.     case WM_INITDLG:
  8789.       {
  8790.          PUCMDATA UCMData = (PUCMDATA)mp2;
  8791.  
  8792.          // Store UCMData in the user field of the dialog
  8793.          WinSetWindowULong(hwnd, QWL_USER, (ULONG)UCMData);
  8794.          InitializeStyleDlg(UCMData, hwnd);
  8795.  
  8796. //       if ( UCMData->hwndHelpInstance ) {
  8797. //          // -------------------------------------------------
  8798. //          // -- The contextual help would work without that
  8799. //          // -- We do it so that the focus goes back on this
  8800. //          // -- dialog after a contextual help invoked from it
  8801. //          // -- has been dismissed ( else the focus goes back
  8802. //          // -- to the closest winassociated window in the
  8803. //          // -- parent and owner chain )
  8804. //          // -------------------------------------------------
  8805. //          WinAssociateHelpInstance( UCMData->hwndHelpInstance, hwnd );
  8806. //       } // endif
  8807.       }
  8808.       break;
  8809.  
  8810.     case WM_CONTROL:
  8811.        switch (SHORT1FROMMP(mp1)) {
  8812.           case IDC_UCMNSTLFORCESIZE:
  8813.           {
  8814.              USHORT usChkst;
  8815.  
  8816.              // This checkbox used to have the opposite effect
  8817.              usChkst     = !WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLFORCESIZE);
  8818.  
  8819.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCX),
  8820.                                usChkst?TRUE:FALSE);
  8821.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCY),
  8822.                                usChkst?TRUE:FALSE);
  8823.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCXLABEL),
  8824.                                usChkst?TRUE:FALSE);
  8825.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCYLABEL),
  8826.                                usChkst?TRUE:FALSE);
  8827.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLIGNORE),
  8828.                                usChkst?TRUE:FALSE);
  8829.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLOR),
  8830.                                usChkst?TRUE:FALSE);
  8831.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLAND),
  8832.                                usChkst?TRUE:FALSE);
  8833.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLBOX),
  8834.                                usChkst?TRUE:FALSE);
  8835.  
  8836.           }
  8837.           break;
  8838.           case IDC_UCMNSTLBUBBLE:
  8839.           {
  8840.              USHORT usChkst;
  8841.  
  8842.              usChkst     = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLBUBBLE);
  8843.  
  8844.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLDELAY),
  8845.                                usChkst?TRUE:FALSE);
  8846.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLREAD),
  8847.                                usChkst?TRUE:FALSE);
  8848.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLDELAYLABEL),
  8849.                                usChkst?TRUE:FALSE);
  8850.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLREADLABEL),
  8851.                                usChkst?TRUE:FALSE);
  8852.              WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLMSECLABEL),
  8853.                                usChkst?TRUE:FALSE);
  8854.  
  8855.           }
  8856.           break;
  8857.        }
  8858.        break;
  8859.     case WM_COMMAND:
  8860.       switch (SHORT1FROMMP(mp1)) {
  8861.         case IDB_UCMNSTLOK:
  8862.           UCMenuStyleDlgOK(hwnd);
  8863.           WinDismissDlg( hwnd, TRUE );
  8864.           return (MRESULT)0;
  8865.         case IDB_UCMNSTLCANCEL:
  8866.           WinDismissDlg(hwnd, FALSE);
  8867.           break;
  8868.       } // endswitch
  8869.       break;
  8870.  
  8871.     case WM_HELP:
  8872.       switch (SHORT1FROMMP(mp1)) {
  8873.       case IDB_UCMNSTLHELP:
  8874.          {
  8875.             PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER);
  8876.             UCMenuDisplayHelp( UCMData,
  8877.                        (USHORT)PANEL_STYLE,
  8878.                        (USHORT)UCN_HLP_STYLE );
  8879.          }
  8880.          break;
  8881.       default:
  8882.         return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  8883.         break;
  8884.       } // endswitch
  8885.  
  8886.     default:
  8887.       return WinDefDlgProc(hwnd, msg, mp1, mp2);
  8888.  
  8889.   } /* endswitch */
  8890.   return (MRESULT)0;
  8891. }
  8892. #endif
  8893.  
  8894. #if defined(UCMUI)
  8895. //----------------------------------------------------------------------------
  8896. // UCMenuDisplayHelp : Not for the user's doc
  8897. //----------------------------------------------------------------------------
  8898. // :pfunction res=&IDF_DISPLAYHLP. name='UCMenuDisplayHelp' text='Pops up a help panel' .
  8899. // This function pops up a style dialog after eventually getting the help instance.
  8900. // :syntax name='UCMenuDisplayHelp' params='UCMData, PanelID, CustomID' return='-'.
  8901. // :fparams.
  8902. // :fparam name='UCMData' type='PUCMDATA' io='output.
  8903. // Pointer to the UCMDATA structure
  8904. // :fparam name='PanelID' type='USHORT' io='input' .
  8905. // ID of the panel to pop up.
  8906. // :fparam name='CustomID' type='USHORT' io='input' .
  8907. // ID ID posted to the owner with UCN_HLP_*  WM_CONTROL notification code in case of custom help.
  8908. // :freturns.
  8909. // :fparam name='-' type='VOID' io='-'.
  8910. // Nothing
  8911. // :efparams.
  8912. // :remarks.
  8913. // :related.
  8914. // :epfunction.
  8915. //----------------------------------------------------------------------------
  8916. VOID  _Optlink UCMenuDisplayHelp(PUCMDATA UCMData, USHORT usPanelID, USHORT usCustomID )
  8917. {
  8918.  
  8919.    if ( UCMData->Style & UCS_CUSTOMHLP ){
  8920.       WinSendMsg( UCMData->hwndOwner,
  8921.                   WM_CONTROL,
  8922.                   MPFROM2SHORT( UCMData->UCMenuID, usCustomID ),
  8923.                   (MPARAM)0 );
  8924.    } else {
  8925.       if ( !UCMData->hwndHelpInstance ) {
  8926.          HELPINIT      hmiHelpData;
  8927.  
  8928.          //-- Initialize the help
  8929.          hmiHelpData.cb                       = (ULONG) sizeof(HELPINIT);
  8930.          hmiHelpData.ulReturnCode             = 0L;
  8931.          hmiHelpData.pszTutorialName          = NULL;
  8932.  
  8933.          hmiHelpData.phtHelpTable             = NULL;
  8934.  
  8935.          hmiHelpData.hmodAccelActionBarModule = (HMODULE)NULL;
  8936.          hmiHelpData.idAccelTable             = 0L;
  8937.          hmiHelpData.idActionBar              = 0L;
  8938.          hmiHelpData.pszHelpWindowTitle       = nlsgetmessage( WinQueryAnchorBlock( UCMData->hwndMenu ), UCMData->hModUCM, NLS_UCMHLP, 0 );
  8939.  
  8940.          hmiHelpData.hmodHelpTableModule      = 0L;
  8941.  
  8942.          hmiHelpData.fShowPanelId             = 0L;
  8943.          hmiHelpData.pszHelpLibraryName       = "UCMENUS.HLP";
  8944.  
  8945.          UCMData->hwndHelpInstance = WinCreateHelpInstance( WinQueryAnchorBlock(UCMData->hwndOwner),
  8946.                                                             &hmiHelpData );
  8947.       } // endif
  8948.       if (UCMData->hwndHelpInstance) {
  8949.          WinSendMsg( UCMData->hwndHelpInstance,
  8950.                      HM_DISPLAY_HELP,
  8951.                      MPFROMSHORT( usPanelID ),
  8952.                      MPFROMSHORT( HM_RESOURCEID ));
  8953.       } // endif
  8954.    } // endif
  8955. }
  8956. #endif
  8957.  
  8958. #if defined(UCMUI)
  8959. //----------------------------------------------------------------------------
  8960. // InitializeStyleDlg : Not for the user's doc
  8961. //----------------------------------------------------------------------------
  8962. // :pfunction res=&IDF_INITSTYLDLG. name='InitializeStyleDlg' text='Initializes the style dialog' .
  8963. // This function initializes the style dialog
  8964. // :syntax name='InitializeStyleDlg' params='UCMData, hwnd' return='-'.
  8965. // :fparams.
  8966. // :fparam name='UCMData' type='PUCMDATA' io='output.
  8967. // Pointer to the UCMDATA structure
  8968. // :fparam name='hwnd' type='HWND' io='input' .
  8969. // Style dialog window handle.
  8970. // :freturns.
  8971. // :fparam name='-' type='VOID' io='-'.
  8972. // Nothing
  8973. // :efparams.
  8974. // :remarks.
  8975. // :related.
  8976. // :epfunction.
  8977. //----------------------------------------------------------------------------
  8978. VOID  _Optlink InitializeStyleDlg(PUCMDATA UCMData, HWND hwnd)
  8979. {
  8980.    RECTL rect;
  8981.  
  8982.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCX),
  8983.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8984.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCY),
  8985.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8986.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCXLABEL),
  8987.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8988.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLCYLABEL),
  8989.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8990.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLIGNORE),
  8991.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8992.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLOR),
  8993.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8994.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLAND),
  8995.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8996.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLBOX),
  8997.                      (UCMData->Style&UCS_FORCESIZE)?TRUE:FALSE);
  8998.  
  8999.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLDELAY),
  9000.                      (UCMData->Style&UCS_BUBBLEHELP)?TRUE:FALSE);
  9001.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLREAD),
  9002.                      (UCMData->Style&UCS_BUBBLEHELP)?TRUE:FALSE);
  9003.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLREADLABEL),
  9004.                      (UCMData->Style&UCS_BUBBLEHELP)?TRUE:FALSE);
  9005.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLDELAYLABEL),
  9006.                      (UCMData->Style&UCS_BUBBLEHELP)?TRUE:FALSE);
  9007.    WinEnableWindow(WinWindowFromID(hwnd, IDC_UCMNSTLMSECLABEL),
  9008.                      (UCMData->Style&UCS_BUBBLEHELP)?TRUE:FALSE);
  9009.  
  9010.    if (UCMData->Style&UCS_FORCESIZE) {
  9011.       rect.xLeft = 0;
  9012.       rect.xRight = UCMData->cx;
  9013.       rect.yBottom = 0;
  9014.       rect.yTop = UCMData->cy;
  9015.    } else {
  9016.       USHORT usItemID;
  9017.  
  9018.       if ( !( usItemID = UCMData->ContextID ) ) {
  9019.          usItemID = (USHORT)WinSendMsg( UCMData->hwndCMOrig, MM_ITEMIDFROMPOSITION, MPFROMSHORT(1), (MPARAM)0 );
  9020.       }  // endif
  9021.       if ( !WinSendMsg(UCMData->hwndCMOrig, MM_QUERYITEMRECT, MPFROM2SHORT( usItemID, TRUE ), MPFROMP( &rect ) ) ){
  9022.          rect.xLeft = 0;
  9023.          rect.xRight = UCMData->cx;
  9024.          rect.yBottom = 0;
  9025.          rect.yTop = UCMData->cy;
  9026.       } // endif
  9027.    } // endif
  9028.  
  9029.    WinSetDlgItemShort( hwnd, IDC_UCMNSTLCX, (USHORT)(rect.xRight - rect.xLeft), FALSE );
  9030.    WinSetDlgItemShort( hwnd, IDC_UCMNSTLCY, (USHORT)(rect.yTop - rect.yBottom), FALSE );
  9031.  
  9032.    WinSendDlgItemMsg(hwnd, IDC_UCMNSTLBUBBLE,
  9033.               BM_SETCHECK,
  9034.               (UCMData->Style&UCS_BUBBLEHELP) ? (MPARAM)1 : (MPARAM)0,
  9035.               (MPARAM)0);
  9036.  
  9037.    WinSetDlgItemShort(hwnd, IDC_UCMNSTLDELAY, UCMData->BubbleDelay, FALSE);
  9038.    WinSetDlgItemShort(hwnd, IDC_UCMNSTLREAD,  UCMData->BubbleRead,  FALSE);
  9039.  
  9040.    WinSendDlgItemMsg(hwnd, IDC_UCMNSTLFORCESIZE,
  9041.               BM_SETCHECK,
  9042.               (UCMData->Style&UCS_FORCESIZE) ? (MPARAM)0 : (MPARAM)1,
  9043.               (MPARAM)0);
  9044.    WinSendDlgItemMsg(hwnd, IDC_UCMNSTLTEXT,
  9045.               BM_SETCHECK,
  9046.               (UCMData->Style&UCS_NOTEXT) ? (MPARAM)0 : (MPARAM)1,
  9047.               (MPARAM)0);
  9048.    WinSendDlgItemMsg(hwnd, IDC_UCMNSTLFRAMED,
  9049.               BM_SETCHECK,
  9050.               (UCMData->Style&UCS_FRAMED) ? (MPARAM)1 : (MPARAM)0,
  9051.               (MPARAM)0);
  9052.    WinSendDlgItemMsg(hwnd, IDC_UCMNSTLIGNORE,
  9053.               BM_SETCHECK,
  9054.               (UCMData->Style&UCS_SHRINK_BLEND) ? (MPARAM)0 : (MPARAM)1,
  9055.               (MPARAM)0);
  9056.    if ( UCMData->Style&UCS_SHRINK_BLEND ) {
  9057.       WinSendDlgItemMsg(hwnd, IDC_UCMNSTLOR,
  9058.                  BM_SETCHECK,
  9059.                  (UCMData->Style&UCS_SHRINK_OR) ? (MPARAM)1 : (MPARAM)0,
  9060.                  (MPARAM)0);
  9061.       WinSendDlgItemMsg(hwnd, IDC_UCMNSTLAND,
  9062.                  BM_SETCHECK,
  9063.                  (UCMData->Style&UCS_SHRINK_OR) ? (MPARAM)0 : (MPARAM)1,
  9064.                  (MPARAM)0);
  9065.    } // endif
  9066. }
  9067. #endif
  9068.  
  9069. #if defined(UCMUI)
  9070. //----------------------------------------------------------------------------
  9071. // UCMenuStyleDlgOK : Not for the user's doc
  9072. //----------------------------------------------------------------------------
  9073. // :pfunction res=&IDF_STYLDLGOK. name='UCMenuStyleDlgOK' text='Processes the OK button for the style dialog' .
  9074. // This function processes the OK button for the style dialog
  9075. // :syntax name='UCMenuStyleDlgOK' params='hwnd' return='-'.
  9076. // :fparams.
  9077. // :fparam name='hwnd' type='HWND' io='input' .
  9078. // Style dialog window handle.
  9079. // :freturns.
  9080. // :fparam name='-' type='VOID' io='-'.
  9081. // Nothing
  9082. // :efparams.
  9083. // :remarks.
  9084. // :related.
  9085. // :epfunction.
  9086. //----------------------------------------------------------------------------
  9087. VOID  _Optlink UCMenuStyleDlgOK(HWND hwnd)
  9088. {
  9089.    USHORT usChkst;
  9090.    PUCMDATA UCMData;
  9091.    ULONG Style;
  9092.  
  9093.    UCMData = (PUCMDATA)WinQueryWindowULong(hwnd, QWL_USER);
  9094.    Style = UCMData->Style;
  9095.  
  9096.    usChkst = !WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLFORCESIZE);
  9097.    if (usChkst) {
  9098.       SHORT sC;
  9099.  
  9100.       Style |= UCS_FORCESIZE;
  9101.       WinQueryDlgItemShort( hwnd, IDC_UCMNSTLCX, &sC, FALSE );
  9102.       UCMData->cx = (sC>4)?((ULONG) sC):4lu;
  9103.       WinQueryDlgItemShort( hwnd, IDC_UCMNSTLCY, &sC, FALSE );
  9104.       UCMData->cy = (sC>10)?((ULONG) sC):10lu;
  9105.    } else {
  9106.       Style &= ~UCS_FORCESIZE;
  9107.    } // endif
  9108.  
  9109.    usChkst = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLBUBBLE);
  9110.    if (usChkst) {
  9111.       SHORT sC;
  9112.  
  9113.       Style |= UCS_BUBBLEHELP;
  9114.       WinQueryDlgItemShort( hwnd, IDC_UCMNSTLDELAY, &sC, FALSE );
  9115.       UCMData->BubbleDelay = (ULONG) sC;
  9116.       WinQueryDlgItemShort( hwnd, IDC_UCMNSTLREAD, &sC, FALSE );
  9117.       UCMData->BubbleRead = (ULONG) sC;
  9118.    } else {
  9119.       Style &= ~UCS_BUBBLEHELP;
  9120.    } // endif
  9121.  
  9122.  
  9123.  
  9124.    usChkst = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLTEXT);
  9125.    if (usChkst) {
  9126.       Style &= ~UCS_NOTEXT;
  9127.    } else {
  9128.       Style |= UCS_NOTEXT;
  9129.    } // endif
  9130.  
  9131.    usChkst = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLFRAMED);
  9132.    if (usChkst) {
  9133.       Style |= UCS_FRAMED;
  9134.    } else {
  9135.       Style &= ~UCS_FRAMED;
  9136.    } // endif
  9137.  
  9138.    usChkst = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLIGNORE);
  9139.    if (usChkst) {
  9140.       Style &= ~UCS_SHRINK_BLEND;
  9141.    } else {
  9142.       Style |= UCS_SHRINK_BLEND;
  9143.    } // endif
  9144.  
  9145.    usChkst = WinQueryButtonCheckstate(hwnd,IDC_UCMNSTLOR);
  9146.    if (usChkst) {
  9147.       Style |= UCS_SHRINK_OR;
  9148.    } else {
  9149.       Style &= ~UCS_SHRINK_OR;
  9150.    } // endif
  9151.  
  9152.    // Send message to update style:
  9153.    WinSendMsg(UCMData->hwndUCM, UCMENU_SETSTYLE, MPFROMLONG(Style), 
  9154.               MPFROM2SHORT(UCMData->cx, UCMData->cy));
  9155.  
  9156.    // Notify owner of change
  9157.    WinSendMsg( UCMData->hwndOwner,
  9158.                WM_CONTROL,
  9159.                MPFROM2SHORT( UCMData->UCMenuID, UCN_STYLE ),
  9160.                MPFROMSHORT( 0 ) );
  9161.  
  9162.    UCMenuUpdateMenu( UCMData->hwndMenu, TRUE );
  9163. }
  9164. #endif
  9165.  
  9166. //----------------------------------------------------------------------------
  9167. // UCMenuUpdateMenu : Not for the user's doc
  9168. //----------------------------------------------------------------------------
  9169. // :pfunction res=&IDF_UPDMENU. name='UCMenuUpdateMenu' text='Updates the display of the ucmenu' .
  9170. // This function refreshes the display of the UCMenu according to the latest changes
  9171. // :syntax name='UCMenuUpdateMenu' params='hwndMenu' return='-'.
  9172. // :fparams.
  9173. // :fparam name='hwndMenu' type='HWND' io='input' .
  9174. // Menu window handle.
  9175. // :freturns.
  9176. // :fparam name='-' type='VOID' io='-'.
  9177. // Nothing
  9178. // :efparams.
  9179. // :remarks.
  9180. // :related.
  9181. // :epfunction.
  9182. //----------------------------------------------------------------------------
  9183. VOID  _Optlink UCMenuUpdateMenu( HWND hwndMenu, BOOL UpdateSubmenus )
  9184. {
  9185.    MENUITEM mi;
  9186.    USHORT ItemID;
  9187.    ULONG Item, NumberOfItems;
  9188.    SWP    swp;
  9189.    PUCMDATA UCMData;
  9190.    ULONG OldMaxVerticalWidth;
  9191.    ULONG OldMaxHorizontalHeight;
  9192.    BOOL    UCMSizeChanged = 0;
  9193.    HWND hwndUCM = WinQueryWindow(hwndMenu, QW_OWNER);
  9194.    ULONG Style = WinQueryWindowULong(hwndUCM, QWL_STYLE);
  9195.  
  9196.    UCMData = (PUCMDATA)WinQueryWindowULong(hwndUCM,QWL_UCMDATA);
  9197.  
  9198.    /* If update is disabled by owner, don't do this */
  9199.    if (UCMData->DisableUpdate)
  9200.      return;
  9201.  
  9202.    //(MAM) Submenus must be updated if anything has changed that
  9203.    // could change the size of the submenu items (e.g. text on
  9204.    // a submenu item, forced size change, various style changes, etc).
  9205.    // Normally, PM asks for the size of submenu items only once (the
  9206.    // first time they are drawn) and assumes they nver change -- even
  9207.    // if the submenu is dismissed and re-started.  To trick PM into
  9208.    // resizing the submenu items, we make a no-affect change to the
  9209.    // presentation parameters.  When that happens, PM will send us
  9210.    // WM_MEASUREITEM messages again, giving us the chance to change the
  9211.    // item sizes. 
  9212.  
  9213.    if (UpdateSubmenus) {
  9214.      if (UCMData->pszFontNameSize != NULL)
  9215.        WinSetPresParam( UCMData->hwndMenu,
  9216.                       PP_FONTNAMESIZE,
  9217.                       strlen(UCMData->pszFontNameSize)+1,
  9218.                       UCMData->pszFontNameSize);
  9219.      else
  9220.        WinSetPresParam( UCMData->hwndMenu,
  9221.                       PP_FONTNAMESIZE,
  9222.                       strlen(UCM_DEFAULTFONT)+1,
  9223.                       UCM_DEFAULTFONT);
  9224.    }
  9225.  
  9226.    OldMaxHorizontalHeight = UCMData->MaxHorizontalHeight;
  9227.    OldMaxVerticalWidth    = UCMData->MaxVerticalWidth;
  9228.  
  9229.    NumberOfItems = (ULONG)WinSendMsg( hwndMenu,
  9230.                                      MM_QUERYITEMCOUNT, 0L, 0L);
  9231.    for(Item=0; Item<NumberOfItems; Item++) {
  9232.       ItemID = (USHORT)WinSendMsg(hwndMenu,
  9233.                                   MM_ITEMIDFROMPOSITION,
  9234.                                   MPFROMSHORT(Item),
  9235.                                   (MPARAM)0);
  9236.  
  9237.       WinSendMsg(hwndMenu,
  9238.                  MM_QUERYITEM,
  9239.                  MPFROM2SHORT(ItemID, TRUE),
  9240.                  MPFROMP(&mi));
  9241.  
  9242.       WinSendMsg(hwndMenu,
  9243.                  MM_SETITEM,
  9244.                  MPFROM2SHORT(0, TRUE),
  9245.                  MPFROMP(&mi));
  9246.    }
  9247.  
  9248.    GetMaxItemSize(UCMData, hwndUCM, hwndMenu);
  9249.  
  9250.    UCMenuSize(hwndMenu, Style);
  9251.  
  9252.    WinQueryWindowPos(UCMData->hwndUCM, &swp);
  9253.  
  9254.    if (Style & CMS_MATRIX) {
  9255.      USHORT Count, Rows;
  9256.      Count = (USHORT)WinSendMsg(hwndMenu, MM_QUERYITEMCOUNT, MPVOID, MPVOID);
  9257.      /* Calculate actual size of matrix menu */
  9258.      if ((Style & CMS_MATRIX_HORZ) != CMS_MATRIX_HORZ)
  9259.        swp.cx = min(Count,UCMData->NbOfCols) * UCMData->MaxVerticalWidth    + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9260.  
  9261.      Rows = Count / max(1,UCMData->NbOfCols);  // Full rows (don't div by zero!)
  9262.      if ((Rows * UCMData->NbOfCols) < Count)   // Partial row?
  9263.        Rows++;
  9264.      if ((Style & CMS_MATRIX_VERT) != CMS_MATRIX_VERT)
  9265.        swp.cy = Rows * UCMData->MaxHorizontalHeight + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9266.      /* This would be theoretical size based on num of rows and cols given by creator */
  9267. //   swp.cx = UCMData->MaxVerticalWidth    * UCMData->NbOfCols + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9268. //   swp.cy = UCMData->MaxHorizontalHeight * UCMData->NbOfRows + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9269.      if ((UCMData->MaxHorizontalHeight != OldMaxHorizontalHeight) ||
  9270.         (UCMData->MaxVerticalWidth != OldMaxVerticalWidth))
  9271.        UCMSizeChanged = 1;
  9272.     }
  9273.  
  9274.    if (Style & CMS_VERT ) {
  9275.      swp.cx = UCMData->MaxVerticalWidth + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9276.      if (UCMData->MaxVerticalWidth != OldMaxVerticalWidth)
  9277.        UCMSizeChanged = 1;
  9278.    } /* endif */
  9279.  
  9280.    if (Style & CMS_HORZ) {
  9281.      swp.cy = UCMData->MaxHorizontalHeight + SUM_UCM_FRAME_THICK + SUM_MENU_FRAME_THICK;
  9282.      if (UCMData->MaxHorizontalHeight != OldMaxHorizontalHeight)
  9283.        UCMSizeChanged = 1;
  9284.    } /* endif */
  9285.  
  9286.    WinSetWindowPos(UCMData->hwndUCM, HWND_TOP, 0, 0, swp.cx, swp.cy, SWP_SIZE);
  9287.  
  9288.    /* Size change notification depends on style of the menu (horz style  */
  9289.    /* notifies only if vert dimension changes, vert style notifies only  */
  9290.    /* if horz dimension changes, matrix notifies if either change).      */
  9291.  
  9292.    if ( UCMSizeChanged ) {
  9293.       WinSendMsg( UCMData->hwndOwner,
  9294.                   WM_CONTROL,
  9295.                   MPFROM2SHORT( UCMData->UCMenuID, UCN_SIZE ),
  9296.                   MPFROMSHORT( 0 ) );
  9297.    } // endif
  9298.  
  9299.    UCMenuUnselectAll( hwndMenu );
  9300. }
  9301.  
  9302.  
  9303. //----------------------------------------------------------------------------
  9304. // UCMenuUnselectAll : Not for the user's doc
  9305. //----------------------------------------------------------------------------
  9306. // :pfunction res=&IDF_UNSELALL. name='UCMenuUnselectAll' text='Unselects all the item of a menu' .
  9307. // This function unselects all the items of a menu and closes the open submenus
  9308. // :syntax name='UCMenuUnselectAll' params='hwndMenu' return='-'.
  9309. // :fparams.
  9310. // :fparam name='hwndMenu' type='HWND' io='input' .
  9311. // Menu window handle.
  9312. // :freturns.
  9313. // :fparam name='-' type='VOID' io='-'.
  9314. // Nothing
  9315. // :efparams.
  9316. // :remarks.
  9317. // :related.
  9318. // :epfunction.
  9319. //----------------------------------------------------------------------------
  9320. VOID _Optlink    UCMenuUnselectAll(HWND hwndMenu)
  9321. {
  9322.    WinSendMsg( hwndMenu, MM_SELECTITEM, MPFROM2SHORT( MIT_NONE, TRUE ), MPFROM2SHORT( 0, TRUE ));
  9323. }
  9324.  
  9325. //----------------------------------------------------------------------------
  9326. // UCMenuGetNewID : Not for the user's doc
  9327. //----------------------------------------------------------------------------
  9328. // :pfunction res=&IDF_NEWID. name='UCMenuGetNewID' text='Get an unused menu ID' .
  9329. // This function returns an unused menu ID
  9330. // :syntax name='UCMenuGetNewID' params='hwndMenu, sID, UCMData' return='ID'.
  9331. // :fparams.
  9332. // :fparam name='hwndMenu' type='HWND' io='input' .
  9333. // Menu window handle.
  9334. // :fparam name='sID' type='SHORT' io='input' .
  9335. // ID used if it doesn't exist already, or MIT_NONE
  9336. // :fparam name='UCMData' type='PUCMDATA' io='input' .
  9337. // UCMData structure associated to the menu, it may not be yet in the QWL_USER
  9338. // :freturns.
  9339. // :fparam name='ID' type='USHORT' io='return'.
  9340. // Max of the IDs + 1 or min - 1 or 0 if failed
  9341. // :efparams.
  9342. // :remarks.
  9343. // :related.
  9344. // :epfunction.
  9345. //----------------------------------------------------------------------------
  9346. USHORT _Optlink UCMenuGetNewID(HWND hwndMenu, SHORT sID, PUCMDATA UCMData)
  9347. {
  9348.   USHORT   NbOfItems=0, ItemID=0, usIndex=0;
  9349.   MENUITEM mi;
  9350.   BOOL     bIDFound;
  9351.  
  9352.   if ( sID == MIT_NONE ){
  9353.      bIDFound = TRUE;
  9354.   } else {
  9355.      bIDFound = FALSE;
  9356.   } // endif
  9357.  
  9358.   memset(&mi, 0, sizeof(MENUITEM));
  9359.  
  9360.   /*┌────────────────────────────────┐
  9361.     │ Query the Number of menu items │
  9362.     └────────────────────────────────┘*/
  9363.   NbOfItems = (USHORT)WinSendMsg(hwndMenu,
  9364.                                  MM_QUERYITEMCOUNT,
  9365.                                  (MPARAM)0,
  9366.                                  (MPARAM)0);
  9367.  
  9368.   for (usIndex=0 ; usIndex<NbOfItems ; usIndex++) {
  9369.     /*┌───────────────────┐
  9370.       │ Query the item id │
  9371.       └───────────────────┘*/
  9372.     ItemID = (SHORT)WinSendMsg(hwndMenu,
  9373.                                MM_ITEMIDFROMPOSITION,
  9374.                                MPFROMSHORT(usIndex),
  9375.                                (MPARAM)0);
  9376.     if ( ItemID == sID ) {
  9377.        bIDFound = TRUE;
  9378.     } // endif
  9379.  
  9380.     /*┌───────────────────┐
  9381.       │ Get the max & min │
  9382.       └───────────────────┘*/
  9383.     if (ItemID>UCMData->MaxID && ItemID<0xFFF0)
  9384.       UCMData->MaxID = ItemID;
  9385.  
  9386.     if (ItemID<(UCMData->MinID) && ItemID>0) {
  9387.       UCMData->MinID = ItemID;
  9388.     } /* endif */
  9389.  
  9390.     /*┌───────────────────┐
  9391.       │ Submenu ?         │
  9392.       └───────────────────┘*/
  9393.     WinSendMsg(hwndMenu,
  9394.                MM_QUERYITEM,
  9395.                MPFROM2SHORT(ItemID, FALSE),
  9396.                MPFROMP(&mi));
  9397.  
  9398.     if (mi.hwndSubMenu) {
  9399.       /*┌───────────────────┐
  9400.         │ recursive call    │
  9401.         └───────────────────┘*/
  9402.       USHORT usSubMenuFound = UCMenuGetNewID( mi.hwndSubMenu, sID, UCMData );
  9403.       if ( (LONG)usSubMenuFound != (LONG)sID ){
  9404.          bIDFound = TRUE;
  9405.       } // endif
  9406.     } /* endif */
  9407.   } /* endfor */
  9408.  
  9409.   if ( !bIDFound ) {
  9410.      return sID;
  9411.   } // endif
  9412.  
  9413.   if (UCMData->MaxID < 0xFFF0) {
  9414.     ItemID = UCMData->MaxID + 1;
  9415.   } else
  9416.   if (UCMData->MinID > 1) {
  9417.     ItemID = UCMData->MinID - 1;
  9418.   } else {
  9419.     ItemID = 0;
  9420.   } /* endif */
  9421.   return (ItemID);
  9422. }
  9423.  
  9424. #if defined(UCMUI)
  9425. //----------------------------------------------------------------------------
  9426. // UCMenuNBP0OK : Not for the user's doc
  9427. //----------------------------------------------------------------------------
  9428. // :pfunction res=&IDF_NBPG0OK. name='UCMenuNBP0OK' text='Processes the OK button for the page 0' .
  9429. // This function processes the OK button for the page 0 of the settings notebook
  9430. // :syntax name='UCMenuNBP0OK' params='hwndPage' return='-' .
  9431. // :fparams.
  9432. // :fparam name='hwndPage' type='HWND' io='input' .
  9433. // Page 0 window handle.
  9434. // :freturns.
  9435. // :fparam name='-' type='BOOL' io='-'.
  9436. // True if processed OK.
  9437. // :efparams.
  9438. // :remarks.
  9439. // :related.
  9440. // :epfunction.
  9441. //----------------------------------------------------------------------------
  9442. BOOL _Optlink UCMenuNBP0OK(HWND hwndPage)
  9443. {
  9444.   MENUITEM mi, oldmi;
  9445.   USHORT   usState = 0;
  9446.   PUCMDATA UCMData;
  9447.  
  9448.   UCMData = (PUCMDATA)WinQueryWindowULong(hwndPage, QWL_USER);
  9449.  
  9450.   memset(&mi, 0, sizeof(MENUITEM));
  9451.  
  9452.   /*┌──────────────────────────────────────────────────────────────┐
  9453.     │ Query the state of the check box                             │
  9454.     └──────────────────────────────────────────────────────────────┘*/
  9455.   usState = (USHORT)WinSendDlgItemMsg(UCMData->hwndPage0,
  9456.                                       IDC_UCMNBP0STATIC,
  9457.                                       BM_QUERYCHECK,
  9458.                                       (MPARAM)0,
  9459.                                       (MPARAM)0);
  9460.   if ( usState ){
  9461.      mi.afStyle = MIS_STATIC | MIS_OWNERDRAW;
  9462.   } else {
  9463.      usState = (USHORT)WinSendDlgItemMsg(UCMData->hwndPage0,
  9464.                                          IDC_UCMNBP0REGULAR,
  9465.                                          BM_QUERYCHECK,
  9466.                                          (MPARAM)0,
  9467.                                          (MPARAM)0);
  9468.      if ( usState ) {
  9469.         mi.afStyle = MIS_OWNERDRAW;
  9470.      } else {
  9471.         mi.afStyle = ( MIS_SPACER | MIS_OWNERDRAW ) & ~MIS_TEXT;
  9472.      } // endif
  9473.   } // endif
  9474.  
  9475.   /*┌──────────────────────────────────────────────────────────────┐
  9476.     │ Query the position                                           │
  9477.     └──────────────────────────────────────────────────────────────┘*/
  9478.   WinSendMsg(UCMData->hwndTemp,
  9479.              MM_QUERYITEM,
  9480.              MPFROM2SHORT(UCMData->ContextID, TRUE),
  9481.              MPFROMP(&oldmi));
  9482.  
  9483.   usState = (USHORT)WinSendDlgItemMsg(UCMData->hwndPage0,
  9484.                                       IDC_UCMNBP0END,
  9485.                                       BM_QUERYCHECK,
  9486.                                       (MPARAM)0,
  9487.                                       (MPARAM)0);
  9488.   if (usState) {
  9489.     mi.iPosition = MIT_END;
  9490.   } else {
  9491.     usState = (USHORT)WinSendDlgItemMsg(UCMData->hwndPage0,
  9492.                                         IDC_UCMNBP0AFTER,
  9493.                                         BM_QUERYCHECK,
  9494.                                         (MPARAM)0,
  9495.                                         (MPARAM)0);
  9496.     if (usState) {
  9497.       mi.iPosition = oldmi.iPosition + 1;
  9498.     } else {
  9499.       mi.iPosition = oldmi.iPosition;
  9500.     } // endif
  9501.   } // endif
  9502.  
  9503.   /*┌──────────────────────────────────────────────────────────────┐
  9504.     │ Query the item ID                                            │
  9505.     │ We actually have to find an unused one.                      │
  9506.     └──────────────────────────────────────────────────────────────┘*/
  9507.   UCMData->MaxID = 0;
  9508.   UCMData->MinID = 0xFFFF;
  9509.   mi.id = UCMenuGetNewID( UCMData->hwndMenu, MIT_NONE, UCMData ) + 1;
  9510.  
  9511.   /*┌─────────────────────────────────┐
  9512.     │Create the item handle structure │
  9513.     └─────────────────────────────────┘*/
  9514.   mi.hItem = (LONG)MyMalloc(sizeof(UCMITEM));
  9515.   if (mi.hItem) {
  9516.     ULONG ulLen;
  9517.  
  9518.     memset((PVOID)mi.hItem, 0, sizeof(UCMITEM));
  9519.  
  9520.     /*┌─────────────────────────────────┐
  9521.       │ Query title text                │
  9522.       └─────────────────────────────────┘*/
  9523.     ulLen = WinQueryDlgItemTextLength(UCMData->hwndPage1, IDC_UCMNBP1TITLE);
  9524.     if (ulLen) {
  9525.       PSZ pszTitle = MyMalloc(ulLen+1);
  9526.       if (pszTitle) {
  9527.         PSZ StrPtr;
  9528.         WinQueryDlgItemText(UCMData->hwndPage1,
  9529.                             IDC_UCMNBP1TITLE,
  9530.                             ulLen+1,
  9531.                             pszTitle);
  9532.         ITEM(&mi, pszText) = pszTitle;
  9533.         if(StrPtr = strstr(pszTitle, "~")) {
  9534.            if(StrPtr[1]) {
  9535.               AddAccelItem(UCMData, StrPtr[1], mi.id);
  9536.            }
  9537.         }
  9538.       } /* endif */
  9539.     } /* endif */
  9540.  
  9541.     /*┌─────────────────────────────────┐
  9542.       │ Go for the bitmap               │
  9543.       └─────────────────────────────────┘*/
  9544.  
  9545.     //---- Is there a file name specified in the dialog ?
  9546.     ulLen = WinQueryDlgItemTextLength(UCMData->hwndPage1, IDC_UCMNBP1FILENAME);
  9547.     if (ulLen) {
  9548.       PSZ pszBitmap = MyMalloc(ulLen+1);
  9549.  
  9550.       if (pszBitmap) {
  9551.         WinQueryDlgItemText(UCMData->hwndPage1,
  9552.                             IDC_UCMNBP1FILENAME,
  9553.                             ulLen+1,
  9554.                             pszBitmap);
  9555.         ITEM(&mi, pszBmp) = pszBitmap;
  9556.       } /* endif */
  9557.       ITEM(&mi, hBmp)    = UCMData->hBmpTemp;
  9558.       if ( UCMData->bBmpTempFromFile ){
  9559.          ITEM( &mi, ulFlags ) |= UCMI_BMPFROMFILE;
  9560.       } else {
  9561.          ITEM( &mi, ulFlags ) &= ~UCMI_BMPFROMFILE;
  9562.       } // endif
  9563.     } /* endif */
  9564.  
  9565.     /*┌─────────────────────────────────┐
  9566.       │ Go for the action               │
  9567.       └─────────────────────────────────┘*/
  9568.     if ( ! ( mi.afStyle & MIS_SPACER ) ){
  9569.       // We don't want any actions associated with spacer items
  9570.       PSZ      pszFunction, pszParams;
  9571.       ULONG    ulLen1, ulLen2;
  9572.  
  9573.       ulLen1 = WinQueryDlgItemTextLength(UCMData->hwndPage2, IDC_UCMNBP2FLIST) + 1;
  9574.       ulLen2 = WinQueryDlgItemTextLength(UCMData->hwndPage2, IDC_UCMNBP2PARAMS) + 1;
  9575.       pszFunction = MyMalloc(ulLen1);
  9576.       pszParams   = MyMalloc(ulLen2);
  9577.       if (pszFunction) {
  9578.          WinQueryDlgItemText( UCMData->hwndPage2,
  9579.                               IDC_UCMNBP2FLIST,
  9580.                               ulLen1,
  9581.                               pszFunction );
  9582.          if (pszParams) {
  9583.             WinQueryDlgItemText( UCMData->hwndPage2,
  9584.                                  IDC_UCMNBP2PARAMS,
  9585.                                  ulLen2,
  9586.                                  pszParams );
  9587.          } // endif
  9588.  
  9589.          ITEM(&mi, pszAction) = pszFunction;
  9590.          ITEM(&mi, pszParameters) = pszParams;
  9591.  
  9592.       } /* endif */
  9593.  
  9594.     } // endif
  9595.   } /* endif */
  9596.  
  9597.  
  9598.   ITEM(&mi, pszData) = NULL;
  9599.  
  9600.   //-- Last check-up before adding item :
  9601.   /*┌──────────────────────────────────────┐
  9602.     │ Last check-up before we add the item │
  9603.     └──────────────────────────────────────┘*/
  9604.   if (mi.hItem && ((ITEM(&mi, hBmp) && ITEM(&mi, pszBmp))||ITEM(&mi,pszText)||(mi.afStyle & MIS_SPACER))) {
  9605.      WinSendMsg(UCMData->hwndCMOrig,
  9606.                 MM_INSERTITEM,
  9607.                 MPFROMP(&mi),
  9608.                 (MPARAM)0);
  9609.     return TRUE;
  9610.   } else {
  9611.        WinMessageBox(HWND_DESKTOP,
  9612.                      HWND_DESKTOP,
  9613.                      nlsgetmessage( WinQueryAnchorBlock( hwndPage ), UCMData->hModUCM, NLS_ITEMADDERROR, 0 ),
  9614.                      nlsgetmessage( WinQueryAnchorBlock( hwndPage ), UCMData->hModUCM, NLS_ERROR, 1 ),
  9615.                      0,
  9616.                      MB_OK | MB_ERROR | MB_APPLMODAL);
  9617.        return FALSE;
  9618.   } /* endif */
  9619. }
  9620. #endif
  9621.  
  9622. //----------------------------------------------------------------------------
  9623. // UCMenuExecuteProgram :
  9624. //----------------------------------------------------------------------------
  9625. // :pfunction res=&IDF_EXECPRGM. name='UCMenuExecuteProgram' text='Executes a program' .
  9626. // This function executes the specified .EXE
  9627. // :syntax name='UCMenuExecuteProgram' params='pszProgName' return='-' .
  9628. // :fparams.
  9629. // :fparam name='psz' type='PSZ' io='input' .
  9630. // String containing the name of the program, followed by some parameters.
  9631. // :freturns.
  9632. // :fparam name='-' type='VOID' io='-'.
  9633. // Nothing
  9634. // :efparams.
  9635. // :remarks.
  9636. // The program is executed synchronously in the same thread.
  9637. // :related.
  9638. // :epfunction.
  9639. //----------------------------------------------------------------------------
  9640. VOID _System UCMenuExecuteProgram(PSZ pszName)
  9641. {
  9642.   PSZ   pszAppli, pszParams;
  9643.   ULONG ulLen;
  9644.  
  9645.   if (pszName) {
  9646.     ulLen = strlen(pszName) + 2;
  9647.     pszParams = MyMalloc(ulLen);
  9648.     if (pszParams) {
  9649.       PSZ psz;
  9650.       strcpy(pszParams, pszName);
  9651.       MyFree( pszName );
  9652.       pszParams[ulLen-1] = '\0';
  9653.       psz = strchr(pszParams, ' ');
  9654.       if (psz) {
  9655.          *psz = '\0';
  9656.          pszAppli = MyStrdup(pszParams);
  9657.       } else {
  9658.          pszAppli = pszParams;
  9659.          pszParams = 0;
  9660.       } // endif
  9661.       if (pszAppli) {
  9662.         RESULTCODES res;
  9663.  
  9664.         DosExecPgm(NULL,
  9665.                    0,
  9666.                    EXEC_SYNC,
  9667.                    pszParams,
  9668.                    NULL,
  9669.                    &res,
  9670.                    pszAppli);
  9671.         MyFree(pszAppli);
  9672.       } /* endif */
  9673.       MyFree(pszParams);
  9674.     } /* endif */
  9675.   } /* endif */
  9676. }
  9677.  
  9678. #if defined(UCMUI)
  9679. //----------------------------------------------------------------------------
  9680. // UCMenuEditBmpFileT2
  9681. //----------------------------------------------------------------------------
  9682. // :pfunction res=&IDF_EDITBMPFILET2. name='UCMenuEditBmpFileT2' text='Edit a bitmap file' .
  9683. // This function starts iconedit with the provided bitmap file name.
  9684. // It is started by UCMenuEditBmpFile in a second thread.
  9685. // :syntax name='UCMenuEditBmpFileT2' params='pArgs' return='-' .
  9686. // :fparams.
  9687. // :fparam name='pArgs' type='PVOID' io='input' .
  9688. // Points to &colon.
  9689. // :dl compact.
  9690. // :dt.hwnd
  9691. // :dd.HWND, handle of the calling notebook page.
  9692. // :dt.pszFileName
  9693. // :dd.PSZ, bitmap file name, freed by UCMenuEditBmpFileT2.
  9694. // Freed by UCMenuEditBmpFileT2.
  9695. // :freturns.
  9696. // :fparam name='-' type='VOID' io='-'.
  9697. // Nothing
  9698. // :efparams.
  9699. // :remarks.
  9700. // The calling convention must be _System because this function
  9701. // is used in a DosCreateThread.
  9702. // :related.
  9703. // UCMenuEditBmpFile
  9704. // :epfunction.
  9705. //----------------------------------------------------------------------------
  9706. VOID _System UCMenuEditBmpFileT2(PVOID pArgs)
  9707. {
  9708.    if ( pArgs ) {
  9709.       PSZ pszArgs, pszFileName, pszIndex;
  9710.       ULONG ulFileNameLength, ulEditorNameLength;
  9711.       PSZ pszBmpEditorName = "iconedit.exe";
  9712.       HWND hwndNBP1;
  9713.       RESULTCODES resultCodes;
  9714.       HAB hab;
  9715.       HMQ hmq;
  9716.       PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndNBP1, QWL_USER );
  9717.  
  9718.       hab = WinInitialize(0);
  9719.       hmq = WinCreateMsgQueue( hab, 0 );
  9720.       hwndNBP1 = *( (HWND *)pArgs );
  9721.  
  9722.       WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1LOAD ),   FALSE );
  9723.       WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1CREATE ), FALSE );
  9724.       WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1EDIT ),   FALSE );
  9725.       WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1PREDEFINED ),   FALSE );
  9726.  
  9727.       pszFileName = *( (PSZ*)( (HWND*)pArgs + 1 ) );
  9728.  
  9729.       ulEditorNameLength = strlen( pszBmpEditorName );
  9730.       ulFileNameLength = strlen( pszFileName );
  9731.  
  9732.       pszArgs = MyMalloc( ulEditorNameLength + ulFileNameLength + 3 );
  9733.       strcpy( pszArgs, pszBmpEditorName );
  9734.       pszIndex = pszArgs + ulEditorNameLength + 1;
  9735.       strcpy( pszIndex, pszFileName );
  9736.       *( pszIndex + ulFileNameLength + 1 ) = '\0';
  9737.  
  9738.       if ( DosExecPgm( NULL, (LONG)0, EXEC_SYNC, pszArgs, NULL, &resultCodes, pszBmpEditorName ) ){
  9739.         WinMessageBox( HWND_DESKTOP, hwndNBP1,
  9740.                        nlsgetmessage( hab, UCMData->hModUCM, NLS_ERROR, 3 ),
  9741.                        nlsgetmessage( hab, UCMData->hModUCM, NLS_NOICESTART, 4 ),
  9742.                        0, MB_OK | MB_ICONEXCLAMATION );
  9743.       }
  9744.  
  9745.       MyFree( pszArgs );
  9746.       MyFree( pArgs );
  9747.  
  9748.       if (resultCodes.codeTerminate==TC_EXIT) {
  9749.          WinSendMsg( hwndNBP1, UCMNBP1_NEWBMP, MPFROMP( pszFileName ), (MPARAM)0 );
  9750.       } else {
  9751.          WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1LOAD ),   TRUE );
  9752.          WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1CREATE ), TRUE );
  9753.          WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1EDIT ),   TRUE );
  9754.          WinEnableWindow( WinWindowFromID( hwndNBP1, IDB_UCMNBP1PREDEFINED ),   TRUE );
  9755.       } // endif
  9756.  
  9757.       MyFree( pszFileName );
  9758.  
  9759.       WinDestroyMsgQueue( hmq );
  9760.       WinTerminate( hab );
  9761.    } // endif
  9762. }
  9763. #endif
  9764.  
  9765. #if defined(UCMUI)
  9766. //----------------------------------------------------------------------------
  9767. // UCMenuEditBmpFile
  9768. //----------------------------------------------------------------------------
  9769. // :pfunction res=&IDF_EDITBMPFILE. name='UCMenuEditBmpFile' text='Edit a bitmap file' .
  9770. // This function starts UCMenuEditBmpFileT2 in a second thread.
  9771. // :syntax name='UCMenuEditBmpFile' params='hwndNBP1, pszBmpFileName' return='-' .
  9772. // :fparams.
  9773. // :fparam name='hwndNBP1' type='HWND' io='input' .
  9774. // Handle of the calling notebook page.
  9775. // :fparam name='pszBmpFileName' type='PSZ' io='input' .
  9776. // Name of the bitmap file to edit, freed by UCMenuEditBmpFileT2.
  9777. // :freturns.
  9778. // :fparam name='-' type='VOID' io='-'.
  9779. // Nothing
  9780. // :efparams.
  9781. // :remarks.
  9782. // :related.
  9783. // UCMenuEditBmpFileT2
  9784. // :epfunction.
  9785. //----------------------------------------------------------------------------
  9786. VOID _Optlink UCMenuEditBmpFile(HWND hwndNBP1, PSZ pszBmpFileName)
  9787. {
  9788.    TID tid;
  9789.    PVOID pArgs;
  9790.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwndNBP1, QWL_USER );
  9791.  
  9792.    pArgs =  MyMalloc( sizeof( HWND ) + sizeof( PSZ ) );
  9793.  
  9794.    if ( pArgs && pszBmpFileName ) {
  9795.       *( (HWND *)pArgs ) = hwndNBP1;
  9796.       *( (PSZ*)( (HWND *)pArgs + 1 ) ) = pszBmpFileName;
  9797.       if ( DosCreateThread( &tid, (PFNTHREAD)UCMenuEditBmpFileT2, (ULONG)pArgs, 0, 8192 ) ){
  9798.          WinMessageBox( HWND_DESKTOP, hwndNBP1,
  9799.                         nlsgetmessage( WinQueryAnchorBlock( hwndNBP1 ), UCMData->hModUCM, NLS_ERROR, 0 ),
  9800.                         nlsgetmessage( WinQueryAnchorBlock( hwndNBP1 ), UCMData->hModUCM, NLS_NOICESTART, 1 ),
  9801.                         0, MB_OK | MB_ICONEXCLAMATION );
  9802.        } // endif
  9803.    } else {
  9804.       WinMessageBox( HWND_DESKTOP, hwndNBP1,
  9805.                      nlsgetmessage( WinQueryAnchorBlock( hwndNBP1 ), UCMData->hModUCM, NLS_ERROR, 0 ),
  9806.                      nlsgetmessage( WinQueryAnchorBlock( hwndNBP1 ), UCMData->hModUCM, NLS_NOBMPFN, 1 ),
  9807.                      0, MB_OK | MB_ICONEXCLAMATION );
  9808.    } // endif
  9809.  
  9810. }
  9811. #endif
  9812.  
  9813. #if defined(UCMUI)
  9814. //----------------------------------------------------------------------------
  9815. // UCMenuCreateBmpFile
  9816. //----------------------------------------------------------------------------
  9817. // :pfunction res=&IDF_CREATEBMPFILE. name='UCMenuCreateBmpFile' text='Create a bitmap file' .
  9818. // This function create a 16 color bitmap file given a name and size.
  9819. // :syntax name='UCMenuCreateBmpFile' params='pszBmpFileName, cx, cy, bpp' return='bSuccess' .
  9820. // :fparams.
  9821. // :fparam name='pszBmpFileName' type='PSZ' io='input' .
  9822. // Name of the bitmap file to create.
  9823. // :fparam name='cx' type='ULONG' io='input' .
  9824. // Width in pixels of the bitmap.
  9825. // :fparam name='cy' type='ULONG' io='input' .
  9826. // Height in pixels of the bitmap.
  9827. // :freturns.
  9828. // :fparam name='bSuccess' type='BOOL' io='return'.
  9829. // True if successful.
  9830. // :efparams.
  9831. // :remarks.
  9832. // :related.
  9833. // :epfunction.
  9834. //----------------------------------------------------------------------------
  9835. BOOL _Optlink UCMenuCreateBmpFile( PSZ pszBmpFileName, ULONG cx, ULONG cy )
  9836. {
  9837.   FILEHANDLE              File;
  9838.   ULONG                   rc;
  9839.   PBITMAPFILEHEADER2      pbfh2  = NULL;
  9840.   PBITMAPINFOHEADER2      pbih2  = NULL;
  9841.   PBITMAPINFO2            pbmi2  = NULL;
  9842.   ULONG                   ulColorTableSize;
  9843.   PBYTE                   pData  = NULL;
  9844.   ULONG                   ulDataSize;
  9845.   BOOL                    bSuccess = FALSE;
  9846.  
  9847.   //--- open the file
  9848.   File = OPENWRITE( pszBmpFileName );
  9849.   if (File == NULLFILE){
  9850.      goto ExitLoadBMP;
  9851.   } // endif
  9852.  
  9853.   /* Write the bitmap info header............................................*/
  9854.   ulColorTableSize = 16 * sizeof( RGB2 );
  9855.   pbfh2 = ( PBITMAPFILEHEADER2 )MyMalloc( sizeof( *pbfh2 ) + ulColorTableSize );
  9856.   if ( !pbfh2 ){
  9857.      goto ExitLoadBMP;
  9858.   } // endif
  9859.  
  9860.   // Fill in the BITMAPFILEHEADER2 structure
  9861.   pbfh2->usType  = BFT_BMAP;
  9862.   pbfh2->cbSize  = sizeof( *pbfh2 );
  9863.   pbfh2->offBits = sizeof( *pbfh2 ) + ulColorTableSize;
  9864.  
  9865.   /* We now assign a bunch of pointers to make the code more readable........*/
  9866.   pbih2 = &pbfh2->bmp2;
  9867.   pbmi2 = (PBITMAPINFO2)pbih2;
  9868.  
  9869.   // Fill in the BITMAPFILEINFOHEADER2 structure
  9870.   memset(  pbih2, '\0', sizeof( *pbih2 ) );
  9871.   pbih2->cbFix = sizeof( *pbih2 );
  9872.   pbih2->cx = cx;
  9873.   pbih2->cy = cy;
  9874.   pbih2->cPlanes = 1;
  9875.   pbih2->cBitCount = 4;
  9876.  
  9877.   // Now fill in the color table
  9878.   pbmi2->argbColor[0].bRed      = 0;
  9879.   pbmi2->argbColor[0].bGreen    = 0;
  9880.   pbmi2->argbColor[0].bBlue     = 0;
  9881.   pbmi2->argbColor[0].fcOptions = 0;
  9882.   pbmi2->argbColor[1].bRed      = 0;
  9883.   pbmi2->argbColor[1].bGreen    = 0;
  9884.   pbmi2->argbColor[1].bBlue     = 0x80;
  9885.   pbmi2->argbColor[1].fcOptions = 0;
  9886.   pbmi2->argbColor[2].bRed      = 0;
  9887.   pbmi2->argbColor[2].bGreen    = 0x80;
  9888.   pbmi2->argbColor[2].bBlue     = 0;
  9889.   pbmi2->argbColor[2].fcOptions = 0;
  9890.   pbmi2->argbColor[3].bRed      = 0;
  9891.   pbmi2->argbColor[3].bGreen    = 0x80;
  9892.   pbmi2->argbColor[3].bBlue     = 0x80;
  9893.   pbmi2->argbColor[3].fcOptions = 0;
  9894.   pbmi2->argbColor[4].bRed      = 0x80;
  9895.   pbmi2->argbColor[4].bGreen    = 0;
  9896.   pbmi2->argbColor[4].bBlue     = 0;
  9897.   pbmi2->argbColor[4].fcOptions = 0;
  9898.   pbmi2->argbColor[5].bRed      = 0x80;
  9899.   pbmi2->argbColor[5].bGreen    = 0;
  9900.   pbmi2->argbColor[5].bBlue     = 0x80;
  9901.   pbmi2->argbColor[5].fcOptions = 0;
  9902.   pbmi2->argbColor[6].bRed      = 0x80;
  9903.   pbmi2->argbColor[6].bGreen    = 0x80;
  9904.   pbmi2->argbColor[6].bBlue     = 0;
  9905.   pbmi2->argbColor[6].fcOptions = 0;
  9906.   pbmi2->argbColor[7].bRed      = 0x80;
  9907.   pbmi2->argbColor[7].bGreen    = 0x80;
  9908.   pbmi2->argbColor[7].bBlue     = 0x80;
  9909.   pbmi2->argbColor[7].fcOptions = 0;
  9910.   pbmi2->argbColor[8].bRed      = 0xC9;
  9911.   pbmi2->argbColor[8].bGreen    = 0xC9;
  9912.   pbmi2->argbColor[8].bBlue     = 0xC9;
  9913.   pbmi2->argbColor[8].fcOptions = 0;
  9914.   pbmi2->argbColor[9].bRed      = 0;
  9915.   pbmi2->argbColor[9].bGreen    = 0;
  9916.   pbmi2->argbColor[9].bBlue     = 0xFF;
  9917.   pbmi2->argbColor[9].fcOptions = 0;
  9918.   pbmi2->argbColor[10].bRed      = 0;
  9919.   pbmi2->argbColor[10].bGreen    = 0xFF;
  9920.   pbmi2->argbColor[10].bBlue     = 0;
  9921.   pbmi2->argbColor[10].fcOptions = 0;
  9922.   pbmi2->argbColor[11].bRed      = 0;
  9923.   pbmi2->argbColor[11].bGreen    = 0xFF;
  9924.   pbmi2->argbColor[11].bBlue     = 0xFF;
  9925.   pbmi2->argbColor[11].fcOptions = 0;
  9926.   pbmi2->argbColor[12].bRed      = 0xFF;
  9927.   pbmi2->argbColor[12].bGreen    = 0;
  9928.   pbmi2->argbColor[12].bBlue     = 0;
  9929.   pbmi2->argbColor[12].fcOptions = 0;
  9930.   pbmi2->argbColor[13].bRed      = 0xFF;
  9931.   pbmi2->argbColor[13].bGreen    = 0;
  9932.   pbmi2->argbColor[13].bBlue     = 0xFF;
  9933.   pbmi2->argbColor[13].fcOptions = 0;
  9934.   pbmi2->argbColor[14].bRed      = 0xFF;
  9935.   pbmi2->argbColor[14].bGreen    = 0xFF;
  9936.   pbmi2->argbColor[14].bBlue     = 0;
  9937.   pbmi2->argbColor[14].fcOptions = 0;
  9938.   pbmi2->argbColor[15].bRed      = 0xFF;
  9939.   pbmi2->argbColor[15].bGreen    = 0xFF;
  9940.   pbmi2->argbColor[15].bBlue     = 0xFF;
  9941.  
  9942.   /* We write a 2.0 image and so we write a bitmap-file header-2 structure...*/
  9943.   rc = WRITEFILE( pbfh2, 1, sizeof( *pbfh2 ) + ulColorTableSize, File );
  9944.   // ! The prototype of fwrite says that the number should be after the size, but
  9945.   // only their product matters, and having the size instead of the number when
  9946.   // there is only one item allows better error checking
  9947.   if ( rc != ( sizeof( *pbfh2 ) + ulColorTableSize ) ){
  9948.      goto ExitLoadBMP;
  9949.   } // endif
  9950.  
  9951.   /* Read the bitmap data, the read size is derived using the magic formula..*/
  9952.   /* The bitmap scan line is aligned on a doubleword boundary................*/
  9953.   /* The size of the scan line is the number of pels times the bpp...........*/
  9954.   /* After aligning it, we divide by 4 to get the number of bytes, and.......*/
  9955.   /* multiply by the number of scan lines and the number of pel planes.......*/
  9956.   ulDataSize = ( ( ( 4 * cx ) + 31) / 32) * 4 * cy;
  9957.   pData = ( PBYTE )MyMalloc( ulDataSize );
  9958.   if ( !pData ){
  9959.      goto ExitLoadBMP;
  9960.   }
  9961.   memset( pData, '\0', ulDataSize );
  9962.   rc = WRITEFILE( pData, 1, ulDataSize, File );
  9963.   if ( rc != ulDataSize ){
  9964.      goto ExitLoadBMP;
  9965.   } // endif
  9966.  
  9967.   bSuccess = TRUE;
  9968.  
  9969. ExitLoadBMP:
  9970.   if ( pData ){
  9971.      MyFree(pData);
  9972.   } // endif
  9973.   if ( pbfh2 ){
  9974.      MyFree( pbfh2 );
  9975.   } // endif
  9976.   CLOSEFILE( File );
  9977.   return bSuccess;
  9978. }
  9979. #endif
  9980.  
  9981. #if defined(UCMUI)
  9982. //----------------------------------------------------------------------------
  9983. // UCMenuNBP1UpdateBmp
  9984. //----------------------------------------------------------------------------
  9985. // :pfunction res=&IDF_NBP1UPDBMP. name='UCMenuNBP1UpdateBmp' text='Update the display of the bitmap in the notebook' .
  9986. // Sets the bitmap of the page 1 of the notebook.
  9987. // :syntax name='UCMenuNBP1UpdateBmp' params='hwnd, hBmp, pszFileName' return='-' .
  9988. // :fparams.
  9989. // :fparam name='hwnd' type='HWND' io='input' .
  9990. // Handle of the notebook page 1
  9991. // :fparam name='hBmp' type='HBITMAP' io='input' .
  9992. // Handle of the bitmap.
  9993. // :fparam name='pszFileName' type='PSZ' io='input' .
  9994. // File name to display for the bitmap.
  9995. // :freturns.
  9996. // :fparam name='-' type='VOID' io='-'.
  9997. // Nothing
  9998. // :efparams.
  9999. // :remarks.
  10000. // :related.
  10001. // :epfunction.
  10002. //----------------------------------------------------------------------------
  10003. VOID _Optlink UCMenuNBP1UpdateBmp(HWND hwnd, PSZ pszFileName)
  10004. {
  10005.    RECTL  rcl;
  10006.    SWP    swp;
  10007.    HPS    hPS = WinGetPS( hwnd );
  10008.  
  10009.    WinQueryWindowPos( WinWindowFromID( hwnd, IDC_UCMNBP1BITMAP ), &swp );
  10010.  
  10011.    rcl.xLeft   = swp.x;
  10012.    rcl.yBottom = swp.y;
  10013.    rcl.xRight  = swp.x + swp.cx;
  10014.    rcl.yTop    = swp.y + swp.cy;
  10015.    WinFillRect( hPS, &rcl, SYSCLR_DIALOGBACKGROUND );
  10016.  
  10017.    WinReleasePS(hPS);
  10018.  
  10019.    WinInvalidateRect( hwnd, &rcl, TRUE );
  10020.  
  10021.    WinSetDlgItemText(hwnd,
  10022.                      IDC_UCMNBP1FILENAME,
  10023.                      pszFileName);
  10024.  
  10025. }
  10026. #endif
  10027.  
  10028. //----------------------------------------------------------------------------
  10029. // UCMenuLoadDefault
  10030. //----------------------------------------------------------------------------
  10031. // :function res=&IDF_UCMLOADDEF. name='UCMenuLoadDefault' text='Loads the default new ucmenu'.
  10032. // This function updates the ucmenu with the default template.
  10033. // :syntax name='UCMenuLoadDefault' params='hwndUCMenu' return='bSuccess' .
  10034. // :fparams.
  10035. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  10036. // Handle of the ucmenu
  10037. // :freturns.
  10038. // :fparam name='bSuccess' type='BOOL' io='return'.
  10039. // True if successful, FALSE else
  10040. // :efparams.
  10041. // :remarks.
  10042. // :related.
  10043. // :efunction.
  10044. //----------------------------------------------------------------------------
  10045. BOOL APIENTRY UCMenuLoadDefault( HWND hwndUCMenu )
  10046. {
  10047.   MRESULT mr;
  10048.   PVOID   pTmplt;
  10049.   HMODULE hModule = NULLHANDLE;
  10050.   USHORT  MenuID  = 0;
  10051.   HWND    hwndNewMenu = NULLHANDLE, hwndOldMenu;
  10052.   ULONG   ulVersion = UCMTMPLVERSION;
  10053.   PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong(hwndUCMenu, QWL_UCMDATA);
  10054.  
  10055.   WinSendMsg( UCMData->hwndOwner,
  10056.                               WM_CONTROL,
  10057.                               MPFROM2SHORT( UCMData->UCMenuID,
  10058.                                             UCN_QRYTEMPLATEMODULE ),
  10059.                               MPFROMP(&hModule));
  10060.   hwndOldMenu = UCMData->hwndMenu;
  10061.  
  10062.   mr = WinSendMsg( UCMData->hwndOwner,
  10063.                                    WM_CONTROL,
  10064.                                    MPFROM2SHORT( UCMData->UCMenuID,
  10065.                                                  UCN_QRYDEFTEMPLATEID ),
  10066.                                    MPFROMP( &MenuID ) );
  10067.   if ( mr ){
  10068.      hwndNewMenu = WinLoadMenu( HWND_OBJECT,
  10069.                                 hModule,
  10070.                                 MenuID );
  10071.   } else {
  10072.      mr = WinSendMsg( UCMData->hwndOwner,
  10073.                                       WM_CONTROL,
  10074.                                       MPFROM2SHORT( UCMData->UCMenuID,
  10075.                                                     UCN_QRYDEFTEMPLATE ),
  10076.                                       MPFROMP( &pTmplt ) );
  10077.  
  10078.      if ( mr ){
  10079.         if ( *( (PULONG)pTmplt ) == UCMTMPLSIG ){
  10080.            ulVersion = *( (PULONG)( (PBYTE)pTmplt + 4 ) );
  10081.            hwndNewMenu = WinCreateMenu( HWND_OBJECT, (PVOID)((PBYTE)pTmplt + 8 ) );
  10082.         } else {
  10083. //           ulVersion = 0;
  10084. //           hwndNewMenu = WinCreateMenu( HWND_OBJECT, pTmplt );
  10085.            return FALSE;
  10086.         } // endif
  10087.         MyFree( pTmplt );
  10088.      } /* endif */
  10089.   } /* endif */
  10090.  
  10091.   if ( hwndNewMenu ) {
  10092.      UCMData->AccelTable->cAccel = 0;
  10093.      UCMenuLoadMenuData( hwndNewMenu, UCMData, ulVersion, hwndUCMenu );
  10094.      UCMenuReplaceMenu( hwndOldMenu, hwndNewMenu );
  10095.   } /* endif */
  10096.  
  10097.   return TRUE;
  10098. }
  10099.  
  10100. //----------------------------------------------------------------------------
  10101. // UCMenuNew
  10102. //----------------------------------------------------------------------------
  10103. // :function res=&IDF_UCMNEW. name='UCMenuNew' text='Loads a new menu in the ucmenu'.
  10104. // This function updates the ucmenu with a new template.
  10105. // :syntax name='UCMenuNew' params='hwndUCMenu, pTemplate' return='bSuccess' .
  10106. // :fparams.
  10107. // :fparam name='hwndUCMenu' type='HWND' io='input' .
  10108. // Handle of the ucmenu
  10109. // :fparam name='pTemplate' type='PVOID' io='input' .
  10110. // Template of the new menu.
  10111. // :freturns.
  10112. // :fparam name='bSuccess' type='BOOL' io='return'.
  10113. // True if successful, FALSE else
  10114. // :efparams.
  10115. // :remarks.
  10116. // :related.
  10117. // :efunction.
  10118. //----------------------------------------------------------------------------
  10119. BOOL APIENTRY UCMenuNew( HWND hwndUCMenu, PVOID pTemplate )
  10120. {
  10121.    HWND  hwndScroll = WinQueryWindow( hwndUCMenu, QW_TOP );
  10122.    HWND  hwndHide   = WinQueryWindow( hwndScroll, QW_TOP );
  10123.    PUCMDATA UCMData = (PUCMDATA) WinQueryWindowULong( hwndUCMenu, QWL_UCMDATA );
  10124.    HWND  hwndNewMenu;
  10125.    ULONG ulVersion;
  10126.  
  10127.    // (MAM) fixed test of unititialized variable
  10128.  
  10129.    if ( UCMData && UCMData->hwndMenu ) {
  10130.       HWND hwndOldMenu = UCMData->hwndMenu;
  10131.       UCMData->AccelTable->cAccel = 0;
  10132.  
  10133.       // Load new-style template (with signature).   Remove comments to
  10134.       // accomodate older (no sig) templates, but then we cannot detect
  10135.       // attempts to load non-UCMenu template files.
  10136.  
  10137.       if ( *( (PULONG)pTemplate ) == UCMTMPLSIG ){
  10138.          ulVersion = *( (PULONG)( (PBYTE)pTemplate + 4 ) );
  10139.          hwndNewMenu = WinCreateMenu( hwndHide, (PVOID)((PBYTE)pTemplate + 8 ) );
  10140.       } else {
  10141. //         ulVersion = 0;
  10142. //         hwndNewMenu = WinCreateMenu( hwndHide, pTemplate );
  10143.          return FALSE;
  10144.       } // endif
  10145.  
  10146.       UCMenuLoadMenuData( hwndNewMenu, UCMData, ulVersion, hwndUCMenu );
  10147.  
  10148.       UCMenuReplaceMenu( hwndOldMenu, hwndNewMenu );
  10149.  
  10150.       return TRUE;
  10151.    } else {
  10152.       return FALSE;
  10153.    } // endif
  10154. }
  10155.  
  10156. //----------------------------------------------------------------------------
  10157. // UCMenuReplaceMenu : not for the user's doc
  10158. //----------------------------------------------------------------------------
  10159. // :pfunction res=&IDF_REPMENU. name='UCMenuReplaceMenu' text='Loads a new menu in the ucmenu'.
  10160. // This function replaces the menu of a ucmenu with a new one.
  10161. // :syntax name='UCMenuReplaceMenu' params='hwndOldMenu, hwndNewMenu' return='-' .
  10162. // :fparams.
  10163. // :fparam name='hwndOldMenu' type='HWND' io='input' .
  10164. // Handle of the old menu
  10165. // :fparam name='hwndNewMenu' type='HWND' io='input' .
  10166. // Handle of the new menu
  10167. // :freturns.
  10168. // :fparam name='-' type='VOID' io='-'.
  10169. // Nothing
  10170. // :efparams.
  10171. // :remarks.
  10172. // Used when we load templates
  10173. // :related.
  10174. // :epfunction.
  10175. //----------------------------------------------------------------------------
  10176. VOID _Optlink UCMenuReplaceMenu(HWND hwndOldMenu, HWND hwndNewMenu)
  10177. {
  10178.   HWND hwndOwner   = WinQueryWindow(hwndOldMenu , QW_OWNER);
  10179.   HWND hwndParent  = WinQueryWindow(hwndOldMenu , QW_PARENT);
  10180.  
  10181.  
  10182.   if (hwndOldMenu && hwndNewMenu) {
  10183.     PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong(hwndOldMenu, QWL_USER);
  10184.  
  10185.     UCMenuFreeMenuData(hwndOldMenu);
  10186.     WinDestroyWindow(hwndOldMenu);
  10187.  
  10188.     UCMData->hwndMenu = hwndNewMenu;
  10189.  
  10190.     WinSetOwner(hwndNewMenu, hwndOwner);
  10191.     WinSetParent(hwndNewMenu, hwndParent, TRUE);
  10192.  
  10193.     // The presparam change has to be done before subclassing the menu, else it fails
  10194.     // (Here, we want to have PRESPARAMCHANGED processed by the default routines only,
  10195.     //  since everything is not set up yet)
  10196.     WinSetPresParam( hwndNewMenu, PP_FONTNAMESIZE,
  10197.                      strlen( UCMData->pszFontNameSize ) + 1,
  10198.                      UCMData->pszFontNameSize );
  10199.     WinSetPresParam( hwndNewMenu, PP_MENUBACKGROUNDCOLOR, sizeof UCMData->ItemBgColor, &(UCMData->ItemBgColor) );
  10200.  
  10201.     UCMData->OldMenuProc = (PFNWP)WinQueryWindowPtr(hwndNewMenu, QWP_PFNWP);
  10202.     UCMData->OldMenuProc = (PFNWP)WinSubclassWindow(hwndNewMenu, (PFNWP)MenuWndProc);
  10203.  
  10204.     UCMenuNotifAll( UCMData, hwndNewMenu, UCN_ADDEDITEM );
  10205.  
  10206.     UCMenuUpdateMenu(hwndNewMenu, FALSE);
  10207.  
  10208.   } // endif
  10209. }
  10210.  
  10211. //----------------------------------------------------------------------------
  10212. // UCMenuInitDrag : not for the user's doc
  10213. //----------------------------------------------------------------------------
  10214. // :pfunction res=&IDF_INITDRAG. name='UCMenuInitDrag' text='Performs initializations at the start of a drag'.
  10215. // This function does some initializations at the beginning of a drag.
  10216. // :syntax name='UCMenuInitDrag' params='hwnd' return='initOK'.
  10217. // :fparams.
  10218. // :fparam name='hwnd' type='HWND' io='input' .
  10219. // Handle of the window from which the drag occurs ( it should be a menu )
  10220. // :fparam name='x' type='SHORT' io='input' .
  10221. // X coordinate of the pointer at the beginning of the drag.
  10222. // :fparam name='y' type='SHORT' io='input' .
  10223. // Y coordinate of the pointer at the beginning of the drag.
  10224. // :freturns.
  10225. // :fparam name='initOK' type='BOOL' io='return'.
  10226. // The initialization went OK
  10227. // :efparams.
  10228. // :remarks.
  10229. // :related.
  10230. // :epfunction.
  10231. //----------------------------------------------------------------------------
  10232.  
  10233. BOOL _Optlink UCMenuInitDrag(HWND hwnd, SHORT x, SHORT y)
  10234. {
  10235.   DRAGITEM                 DragItem;
  10236.   DRAGIMAGE                DragImage;
  10237.   DRAGINFO                *pDragInfo;
  10238.   POINTL                   ptl;
  10239.   MENUITEM                 mItem;
  10240.   HBITMAP                  hBitmap;
  10241.   PID                      pid;
  10242.   TID                      tid;
  10243.   PUCMDATA                 UCMData;
  10244.   BOOL                     bFileBitmap = FALSE;
  10245.   // (MAM) Added flag to delete newly loaded bitmap after drag
  10246.   BOOL                     DeleteBitmap = FALSE;  
  10247.   QMSG                     QMsg;
  10248.  
  10249.   UCMData = (PUCMDATA) WinQueryWindowULong(hwnd , QWL_USER);
  10250.  
  10251.   // ------------------------------------------
  10252.   // -- First check if drag and drop is allowed
  10253.   // ------------------------------------------
  10254.   if ( UCMData->Style & UCS_NO_DM) {
  10255.      return FALSE;
  10256.   } // endif
  10257.  
  10258.   WinQueryWindowProcess( hwnd, &pid, &tid );
  10259.  
  10260.   ptl.x = x;
  10261.   ptl.y = y;
  10262.   UCMData->ContextID = UCMenuIdFromCoord(hwnd, &ptl);
  10263.   if ( ! UCMData->ContextID ) {
  10264.      return FALSE;
  10265.   } // endif
  10266.   memset(&mItem, 0, sizeof(MENUITEM));
  10267.   WinSendMsg(hwnd, MM_QUERYITEM, MPFROM2SHORT(UCMData->ContextID, FALSE), MPFROMP(&mItem)); 
  10268.  
  10269.   if (mItem.hItem && ITEM(&mItem, hBmp)) {
  10270. //  PSZ pszFileExt;
  10271.     BOOL BinOK;
  10272.     hBitmap = ITEM(&mItem, hBmp);
  10273.     // ------------------------------------------------------
  10274.     // -- pszBmp can be a bitmap ID or a file name.  If it
  10275.     // -- converts to binary without error we set bFileBitmap
  10276.     // -- to TRUE.
  10277.     // ------------------------------------------------------
  10278.     if (ITEM(&mItem, pszBmp)) {  // There is a bitmap string...
  10279.        UCMString2Int(ITEM(&mItem, pszBmp), &BinOK);
  10280.        if ((!BinOK) && !(UCMData->Style & UCS_NO_DM_RENDER_TO_BMP))
  10281.          bFileBitmap = TRUE;    // Not a number, must be a filename
  10282.     }
  10283. //...old method, non-NLS...
  10284. //  pszFileExt = strrchr( ITEM( &mItem, pszBmp ), '.' );
  10285. //
  10286. //  if ( !(UCMData->Style & UCS_NO_DM_RENDER_TO_BMP)
  10287. //    && pszFileExt
  10288. //    && strlen(pszFileExt)>3
  10289. //    && toupper(pszFileExt[1])=='B'
  10290. //    && toupper(pszFileExt[2])=='M'
  10291. //    && toupper(pszFileExt[3])=='P' ) {
  10292. //     bFileBitmap = TRUE;
  10293. //  } // endif
  10294.   } else {
  10295.     // fix 03/07/95 (MAM)
  10296.     // Cannot use DrgGetPS()/DrgReleasePS() during WM_BEGINDRAG processing.
  10297.     // We must get our own PS to load the bitmap.
  10298.     HPS hps;
  10299.     HDC hdc;
  10300.     SIZEL PSSize={0,0};
  10301.     DEVOPENSTRUC DevOS={NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL};
  10302.  
  10303.     /* Create memory device context to load bitmap */
  10304.     hdc = DevOpenDC((HAB)NULLHANDLE, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&DevOS, NULLHANDLE);
  10305.     hps = GpiCreatePS((HAB)NULLHANDLE, hdc, &PSSize, GPIA_ASSOC | PU_PELS | GPIT_MICRO);
  10306.     if (mItem.afStyle & MIS_SPACER) /* Give spacer items a different look */
  10307.       hBitmap = GpiLoadBitmap( hps, UCMData->hModUCM, UCMENUID_SPACERBMP,  0, 0 );
  10308.     else
  10309.       hBitmap = GpiLoadBitmap( hps, UCMData->hModUCM, UCMENUID_DEFAULTBMP, 0, 0 );
  10310.  
  10311.     GpiDestroyPS(hps);
  10312.     DevCloseDC(hdc);
  10313.     DeleteBitmap = TRUE;  /* Delete this bitmap afer drag is done */
  10314.   } // endif
  10315.  
  10316.   // ---------------------------------------------------------------------
  10317.   // -- If we are dragging an open nodismiss submenu, we close it before
  10318.   // -- Else it would cause problems when it is dropped on another ucmenu
  10319.   // -- where UCMData->oldSubMenuProc is not yet set
  10320.   // ---------------------------------------------------------------------
  10321.   if ( WinSendMsg( hwnd,
  10322.                    MM_QUERYITEMATTR,
  10323.                    MPFROM2SHORT( mItem.id, FALSE ),
  10324.                    MPFROMSHORT( MIA_HILITED ) ) ){
  10325.      WinSendMsg( hwnd,
  10326.                  MM_SETITEMATTR,
  10327.                  MPFROM2SHORT( mItem.id, FALSE ),
  10328.                  MPFROM2SHORT( MIA_HILITED, FALSE ) );
  10329.      if (mItem.hwndSubMenu) {
  10330.         UCMenuUnselectAll( UCMData->hwndMenu );
  10331.      } // endif
  10332.   } // endif
  10333.  
  10334.   pDragInfo = DrgAllocDraginfo(1);
  10335.   if (pDragInfo == NULL) {
  10336.     return 0;
  10337.   }
  10338.  
  10339.   // -------------------------------------------------------------------------------------
  10340.   // -- DC_REMOVEABLEMEDIA prevents the desktop from doing a move by default
  10341.   // -- Else, whenever an item with a bitmap file is mistakenly dropped on the desktop,
  10342.   // -- the file is moved into the desktop directory and the ucmenu can not find it again
  10343.   // -------------------------------------------------------------------------------------
  10344.   DragItem.fsControl         = DC_REMOVEABLEMEDIA;
  10345.  
  10346.   DragItem.ulItemID          = UCMData->ContextID;
  10347.  
  10348.   // ------------------------------------------------------------------------------
  10349.   // -- We can either render as a bitmap file or as a ucmenu item
  10350.   // -- We will fill them only if it can be rendered as a bitmap file
  10351.   // -- In case   a ucmenu item rendering is wanted, a DM_RENDER will be necessary
  10352.   // ------------------------------------------------------------------------------
  10353.   DragItem.hstrContainerName = 0;
  10354.   DragItem.hstrSourceName    = 0;
  10355.  
  10356.   DragItem.hwndItem          = hwnd;                 // -- hwnd of the source window (ie menu or submenu)
  10357.   DragItem.hstrTargetName    = 0;
  10358.   DragItem.fsSupportedOps    = DO_COPYABLE | DO_MOVEABLE;
  10359.   if ( bFileBitmap ) {
  10360.      PSZ   pszNameOnly;
  10361.      PSZ   pszFullNameCopy;
  10362.  
  10363.      // -------------------------------------------------------------------------------------
  10364.      // -- If the item can be rendered  as a bitmap file, we set it up so that its true type
  10365.      // -- and native RMF are those of an actual BMP file -> the order in the following
  10366.      // -- strings is important. Else, some applications, eg iconedit, won't accept it.
  10367.      // -------------------------------------------------------------------------------------
  10368.      DragItem.hstrType = DrgAddStrHandle( DRT_BITMAP "," DRT_UCMITEM ","  DRT_TEXT "," DRT_UNKNOWN );
  10369.      if (UCMData->Style&UCS_NO_DM_DISCARD) {
  10370.         DragItem.hstrRMF  = DrgAddStrHandle("<DRM_OS2FILE, DRF_TEXT>,<DRM_UCMITEM, DRF_UNKNOWN>");
  10371.      } else {
  10372.         DragItem.hstrRMF  = DrgAddStrHandle("<DRM_OS2FILE, DRF_TEXT>,(DRM_UCMITEM, DRM_DISCARD)X(DRF_UNKNOWN)");
  10373.      } // endif
  10374.  
  10375.      pszFullNameCopy = MyStrdup( ITEM( &mItem, pszBmp ) );
  10376.      pszNameOnly = strrchr( pszFullNameCopy, '\\' );
  10377.      pszNameOnly++;
  10378.      DragItem.hstrSourceName    = DrgAddStrHandle( pszNameOnly );
  10379.      * pszNameOnly = '\0';
  10380.      DragItem.hstrContainerName = DrgAddStrHandle( pszFullNameCopy );
  10381.   } else {
  10382.      DragItem.hstrType = DrgAddStrHandle(DRT_UCMITEM ", " DRT_UNKNOWN);
  10383.      if (UCMData->Style&UCS_NO_DM_DISCARD) {
  10384.         DragItem.hstrRMF  = DrgAddStrHandle("<DRM_UCMITEM, DRF_UNKNOWN>");
  10385.      } else {
  10386.         DragItem.hstrRMF  = DrgAddStrHandle("(DRM_UCMITEM, DRM_DISCARD)X(DRF_UNKNOWN)");
  10387.      } // endif
  10388.   } // endif
  10389.  
  10390.   DragImage.cb               = sizeof(DRAGIMAGE);
  10391.   DragImage.hImage           = hBitmap;
  10392.   DragImage.fl               = DRG_BITMAP;
  10393.   DragImage.cxOffset         = 0;
  10394.   DragImage.cyOffset         = 0;
  10395.  
  10396.   //(MAM) Allow submenus to be source of drag operations, just like main menus
  10397.   pDragInfo->hwndSource      = hwnd;
  10398. //pDragInfo->hwndSource      = UCMData->hwndMenu;   // -- always the handle of the menu, never of the submenu
  10399.   DrgSetDragitem(pDragInfo, &DragItem, sizeof(DRAGITEM), 0);
  10400.  
  10401.   /* Dispatch any waiting messages */
  10402.   while (WinPeekMsg((HAB)NULLHANDLE, &QMsg, NULLHANDLE, 0, 0, PM_REMOVE)) {
  10403.     WinDispatchMsg((HAB)NULLHANDLE, &QMsg);
  10404.   }
  10405.  
  10406.   DrgDrag(hwnd,
  10407.           pDragInfo,
  10408.           &DragImage,
  10409.           1,
  10410.           VK_BUTTON2,
  10411.           DRAGDEBUG);
  10412.  
  10413.   // (MAM) Delete bitmap we loaded just for dragging
  10414.   if (DeleteBitmap)
  10415.     GpiDeleteBitmap(hBitmap);
  10416.  
  10417.   DrgAccessDraginfo          (pDragInfo);
  10418.   DrgDeleteDraginfoStrHandles(pDragInfo);
  10419.   DrgFreeDraginfo            (pDragInfo);
  10420.  
  10421.   return TRUE;
  10422. }
  10423.  
  10424. //----------------------------------------------------------------------------
  10425. // UCMenuDrgDrpMsg : not for the user's doc
  10426. //----------------------------------------------------------------------------
  10427. // :pfunction res=&IDF_DRGDRPMSG. name='UCMenuDrgDrpMsg' text='Processes the drag&drop messages'.
  10428. // This function processes the drag & drop messages  for the menu & ucmenu window procedures
  10429. // :syntax name='UCMenuDrgDrpMsg' params='hwnd, msg, mp1, mp2, WindowProc ' return='rc'.
  10430. // :fparams.
  10431. // :fparam name='hwnd' type='HWND' io='input' .
  10432. // Handle of the window where the message occurs
  10433. // :fparam name='msg' type='ULONG' io='input' .
  10434. // Message given to the window proc
  10435. // :fparam name='mp1' type='MPARAM' io='input' .
  10436. // First parameter of the message given to the window proc
  10437. // :fparam name='mp2' type='MPARAM' io='input' .
  10438. // Second parameter of the message given to the window proc
  10439. // :fparam name='WindowProc' type='PFNWP' io='input' .
  10440. // Window porcedure to call if we do not process the message.
  10441. // :freturns.
  10442. // :fparam name='rc' type='MRESULT' io='return'.
  10443. // Return code for a PM message
  10444. // :efparams.
  10445. // :remarks.
  10446. // :related.
  10447. // :epfunction.
  10448. //----------------------------------------------------------------------------
  10449.  
  10450. MRESULT _Optlink UCMenuDrgDrpMsg(PUCMDATA UCMData, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, PFNWP WindowProc)
  10451. {
  10452.   switch (msg) {
  10453.      #if defined(MSG_DEBUGMESSAGE)
  10454.      case MSG_DEBUGMESSAGE:
  10455.        WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,(char *)mp1,"Debug message:",0,MB_OK);
  10456.        return 0;
  10457.      #endif
  10458.  
  10459.      case WM_BEGINDRAG: {
  10460.        MRESULT rc;
  10461.        POINTL  CurrMousePos;
  10462.  
  10463.        rc = (MRESULT) UCMenuInitDrag( hwnd, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) );
  10464.        /* Re-enable bubble help when drag is done.  It was disabled when */
  10465.        /* the BUTTONxDOWN that started the drag occured.                 */
  10466.        if (UCMData->Style & UCS_BUBBLEHELP) {
  10467.          /* We lose track of the mouse position during drag/drop, so we  */
  10468.          /* send a fake mousemove message to regain tracking.            */
  10469.          WinQueryPointerPos(HWND_DESKTOP, &CurrMousePos);
  10470.          WinMapWindowPoints(HWND_DESKTOP, hwnd, &CurrMousePos, 1);
  10471.          WinSendMsg(hwnd, WM_MOUSEMOVE, MPFROM2SHORT(CurrMousePos.x, CurrMousePos.y), MPFROM2SHORT(1, KC_NONE));
  10472.          /* If button 2 was not release (e.g. drag was termianted by  */
  10473.          /* ESC key, PF1 or some other way), recapture mouse so we    */
  10474.          /* will see the BUTTON2UP message and re-enable bubble help  */
  10475.          /* at that time.  If drag ended normally (button 2 is up)    */
  10476.          /* then we can just re-enable the bubble-help now.           */
  10477. //...OK? if (WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000) {
  10478. //         WinSetCapture(HWND_DESKTOP, hwnd);
  10479. //         UCMData->HoverCapture = TRUE;
  10480. //       }
  10481. //       else {
  10482.            WinSendMsg(UCMData->hwndBubble, MSG_ENABLE_BUBBLE, 0L, 0L);
  10483. //       }
  10484.        }
  10485.        return rc;
  10486.        }
  10487.  
  10488.      case DM_ENDCONVERSATION:
  10489.        // -- All our "conversation resources" are released before returning
  10490.        // -- from DM_RENDER so we do nothing here.
  10491.        return (MRESULT)0;
  10492.  
  10493.      case DM_RENDERPREPARE:
  10494.        // -- Since we don't set DC_PREPARE in the DRAGITEM structures from the
  10495.        // -- dragged items, this message should never be received
  10496.        // -- In case this would happen, should we DrgFreeDragTransfer
  10497.        // --  the DRAGTRANSFER structure?
  10498.        return (MRESULT)FALSE;
  10499.  
  10500.      case DM_RENDER:
  10501.        { PDRAGTRANSFER  pdxfer;
  10502.          MENUITEM     * pMiTransfer;
  10503.          UCMITEM      * pUCMTransfer;
  10504.          UCHAR          pszRMF[30];      // -- "<DRM_UCMITEM,DRF_UNKNOWN>" must fit in
  10505.          BOOL           bSuccess = TRUE;
  10506.  
  10507.          pdxfer = (PDRAGTRANSFER)mp1;
  10508.  
  10509.          DrgQueryStrName(pdxfer->hstrSelectedRMF, sizeof(pszRMF), pszRMF);
  10510.          if ( strstr( pszRMF, "<DRM_UCMITEM,DRF_UNKNOWN>" ) )
  10511.          {
  10512.             CHAR pszItemPtr[20];
  10513.   
  10514.             // ---------------------------------------------------------------
  10515.             // -- ulTargetInfo contains the address of the shared memory
  10516.             // --  if source and target are in different processes and 0 else
  10517.             // ---------------------------------------------------------------
  10518.             if (pdxfer->ulTargetInfo) {
  10519.                DosSubSetMem ( (PVOID)(pdxfer->ulTargetInfo), 0, 4000 );
  10520.                DosSubAllocMem( (PVOID)(pdxfer->ulTargetInfo),(PVOID)&pMiTransfer, sizeof(MENUITEM) );
  10521.             } else {
  10522.                pMiTransfer = MyMalloc( sizeof(MENUITEM) );
  10523.             } // endif
  10524.   
  10525.             memset( pMiTransfer, 0, sizeof(MENUITEM) );
  10526.             WinSendMsg(hwnd,
  10527.                        MM_QUERYITEM,
  10528.                        MPFROM2SHORT((SHORT)(pdxfer->pditem->ulItemID), TRUE),
  10529.                        MPFROMP(pMiTransfer));
  10530.             if (pMiTransfer->hItem && pdxfer->ulTargetInfo) {
  10531.                // --------------------------------------------------------------------
  10532.                // -- pMiTransfer->hItem is a pointer to a UCMItem structure which is
  10533.                // -- allocated in our process, so we have to copy it in shared mem too
  10534.                // --------------------------------------------------------------------
  10535.                UCMITEM * pUCMItem;
  10536.   
  10537.                pUCMItem = (UCMITEM*)(pMiTransfer->hItem);
  10538.                DosSubAllocMem( (PVOID)(pdxfer->ulTargetInfo),(PPVOID)&(pMiTransfer->hItem), sizeof(UCMITEM) );
  10539.   
  10540.                ITEM(pMiTransfer, hBmp   ) = pUCMItem->hBmp;
  10541.                ITEM(pMiTransfer, pszBmp ) = SubMemStrdup( (PVOID)(pdxfer->ulTargetInfo), pUCMItem->pszBmp );
  10542.                ITEM(pMiTransfer, pszText) = SubMemStrdup( (PVOID)(pdxfer->ulTargetInfo), pUCMItem->pszText );
  10543.                ITEM(pMiTransfer, pszAction) = SubMemStrdup( (PVOID)(pdxfer->ulTargetInfo), pUCMItem->pszAction );
  10544.                ITEM(pMiTransfer, pszParameters ) = SubMemStrdup( (PVOID)(pdxfer->ulTargetInfo), pUCMItem->pszParameters );
  10545.                ITEM(pMiTransfer, pszData) = SubMemStrdup( (PVOID)(pdxfer->ulTargetInfo), pUCMItem->pszData );
  10546.             } // endif
  10547.   
  10548.             sprintf( pszItemPtr, "%u", pMiTransfer );
  10549.             pdxfer->pditem->hstrSourceName = DrgAddStrHandle( pszItemPtr );
  10550.   
  10551.          } else if ( strstr( pszRMF, "<DRM_OS2FILE,DRF_TEXT>" ) ){
  10552.             // ---------------------------------------------------
  10553.             // -- A bmp file rendering is requested
  10554.             // -- We tell the target to do it by itself!
  10555.             // -- (we supplied all the necessary informations)
  10556.             // ---------------------------------------------------
  10557.             pdxfer->fsReply = DMFL_NATIVERENDER;
  10558.             bSuccess = FALSE;
  10559.          } else {
  10560.             // ------------------------------------
  10561.             // -- We don't know how to render that
  10562.             // ------------------------------------
  10563.             bSuccess = FALSE;
  10564.          } // endif RMF checking
  10565.   
  10566.          if (pdxfer->ulTargetInfo){
  10567.             DosSubUnsetMem((PVOID)(pdxfer->ulTargetInfo));
  10568.             DosFreeMem((PVOID)(pdxfer->ulTargetInfo));
  10569.          } // endif
  10570.   
  10571.          // ---------------------------------------------------------------------
  10572.          // -- Free the drag transfer structure
  10573.          // ---------------------------------------------------------------------
  10574.          DrgDeleteStrHandle( pdxfer->hstrSelectedRMF );
  10575.          DrgFreeDragtransfer( pdxfer );
  10576.  
  10577.          return (MRESULT)bSuccess;
  10578.        }
  10579.  
  10580.      case DM_DISCARDOBJECT:
  10581.      // ------------------------------------------------------------------
  10582.      // -- Discard a menu item (dragged to the shredder for instance)
  10583.      // -- We return DRR_SOURCE, which means we handle the delete action
  10584.      // ------------------------------------------------------------------
  10585.        {
  10586.          WinSendMsg(WinQueryWindow(hwnd, QW_OWNER),
  10587.                     MM_DELETEITEM,
  10588.                     MPFROM2SHORT(UCMData->ContextID, TRUE),
  10589.                     (MPARAM)0);
  10590.        }
  10591.        return (MRESULT)DRR_SOURCE;
  10592.  
  10593.      case DM_DRAGOVER:
  10594.       // --------------------------------------------------------------------
  10595.       // -- We get this message when the drag icon is moved over our window.
  10596.       // -- We draw an emphasis frame around the item
  10597.       // -- We must verify whether or not we want to accept the drop.
  10598.       // --------------------------------------------------------------------
  10599.       {
  10600.          RECTL    rcl;
  10601.          POINTL   ptl;
  10602.          USHORT   targetID;
  10603.          BOOL     fSuccess, fSuccess2;
  10604.          MENUITEM mi;
  10605.  
  10606.          ptl.x = SHORT1FROMMP( mp2 );
  10607.          ptl.y = SHORT2FROMMP( mp2 );
  10608.          WinMapWindowPoints( HWND_DESKTOP, hwnd, &ptl, 1);
  10609.          targetID = UCMenuIdFromCoord(hwnd, &ptl);
  10610.  
  10611.          if (UCMData->TargetID != targetID) {
  10612.             HPS hps  = DrgGetPS( hwnd );
  10613.  
  10614.             // Remove the frame of the quitted item
  10615.             fSuccess  = (BOOL) WinSendMsg( hwnd,
  10616.                                            MM_QUERYITEMRECT,
  10617.                                            MPFROM2SHORT( UCMData->TargetID, TRUE ),
  10618.                                            MPFROMP( &rcl ));
  10619.             fSuccess2 = (BOOL) WinSendMsg( hwnd,
  10620.                                            MM_QUERYITEM,
  10621.                                            MPFROM2SHORT( UCMData->TargetID, TRUE ),
  10622.                                            MPFROMP( &mi ) );
  10623.             if ( fSuccess && fSuccess2 ){
  10624.                ULONG ColorIndex;
  10625.  
  10626.                if (WinIsMenuItemChecked(hwnd,UCMData->TargetID)) {
  10627.                   ColorIndex = CLR_BLACK;
  10628.                } else if ( mi.afStyle & MIS_SPACER ){
  10629.                   ColorIndex = UCMenuSelectColor( UCMData->BgColor, hps );
  10630.                } else {
  10631.                   ColorIndex = UCMenuSelectColor( UCMData->ItemBgColor, hps );
  10632.                } // endif
  10633.  
  10634.                rcl.xLeft   += 1;
  10635.                rcl.yBottom += 1;
  10636.                rcl.yTop    -= 1;
  10637.                rcl.xRight  -= 1;
  10638.  
  10639.                WinDrawBorder( hps, &rcl, 1, 1, ColorIndex, 0, DB_PATCOPY);
  10640.             } // endif
  10641.  
  10642.             // -- Draw a frame around the entered item
  10643.             fSuccess = (BOOL) WinSendMsg( hwnd,
  10644.                                           MM_QUERYITEMRECT,
  10645.                                           MPFROM2SHORT( targetID, TRUE ),
  10646.                                           MPFROMP( &rcl ));
  10647.             if (fSuccess) {
  10648.                rcl.xLeft   += 1;
  10649.                rcl.yBottom += 1;
  10650.                rcl.yTop    -= 1;
  10651.                rcl.xRight  -= 1;
  10652.  
  10653.                WinDrawBorder( hps, &rcl, 1, 1, CLR_BLACK, 0, DB_PATCOPY);
  10654.             } // endif
  10655.  
  10656.             UCMData->TargetID = targetID;
  10657.  
  10658.             DrgReleasePS( hps );
  10659.  
  10660.          } // endif UCMData->TargetID != targetID
  10661.  
  10662.  
  10663.          return (MRESULT)(UCMenuDragOver(UCMData, hwnd,(PDRAGINFO) mp1));
  10664.  
  10665.       }
  10666.  
  10667.  
  10668.     case DM_DRAGLEAVE:
  10669.       // -------------------------------------------------------------
  10670.       // -- We get this message when the drag icon leaves our window.
  10671.       // -- If any clean up is needed, this is the place.
  10672.       // -------------------------------------------------------------
  10673.       {
  10674.  
  10675.          UCMenuRemoveDropEmphasis( UCMData, hwnd );
  10676.  
  10677.          return (MRESULT)0;
  10678.       }
  10679.  
  10680.     #if defined(UCMUI)
  10681.     case DM_DROPHELP:
  10682.       // ---------------------------------------------------------------------
  10683.       // -- Help for Drag Drop.  This message is POSTED to use if the user
  10684.       // -- pressed F1 during a drag operation.  Note that the WM_BEGINDRAG
  10685.       // -- processing has already completed since this is posted, not sent.
  10686.       // ---------------------------------------------------------------------
  10687.       {
  10688.  
  10689.          UCMenuDisplayHelp( UCMData,
  10690.                             (USHORT)PANEL_DM,
  10691.                             (USHORT)UCN_HLP_DM );
  10692.          return (MRESULT)0;
  10693.       }
  10694.     #endif
  10695.  
  10696.     case DM_DROP:
  10697.       // ---------------------------------------------------------------------
  10698.       // -- Some application has just Dropped something on us !!
  10699.       // ---------------------------------------------------------------------
  10700.       UCMenuDrop(hwnd, (PDRAGINFO)mp1) ;
  10701.       return (MRESULT)0;
  10702.  
  10703.     case DM_RENDERCOMPLETE:
  10704.       // ----------------------------------------------------------------------------------
  10705.       // -- Some application has just Dropped something on us, but it was
  10706.       // -- an incomplete drop specification.  So we asked for a rendering with DM_RENDER.
  10707.       // -- However, in all the cases we process the rendering we need is done when we
  10708.       // -- get the reply from DM_RENDER, so we do nothing here.
  10709.       // -- We would do something eg if the source had to copy a file for us and was
  10710.       // -- doing it asynchronously, but we just need the names and location of bmp files,
  10711.       // -- which are given in the DM_RENDER reply.
  10712.       // ----------------------------------------------------------------------------------
  10713.       return (MRESULT)0;
  10714.  
  10715.     default:
  10716.       return WindowProc(hwnd, msg, mp1, mp2);
  10717.  
  10718.    } // endswitch
  10719. }
  10720.  
  10721. //----------------------------------------------------------------------------
  10722. // UCMenuRemoveDropEmphasis : not for the user's doc
  10723. //----------------------------------------------------------------------------
  10724. // :pfunction res=&IDF_RMVEMPH. name='UCMenuRemoveDropEmphasis'
  10725. //   text='Called to remove the current drop emphasis'.
  10726. // This function is called to remove the emphasis frame drawn around the item being
  10727. //  currently dragged over.
  10728. // :syntax name='UCMenuRemoveDropEmphasis' params='UCMData, hwnd' return='-'.
  10729. // :fparams.
  10730. // :fparam name='UCMData' type='PUCMDATA' io='input' .
  10731. // Pointer to the structure associated to the ucmenu.
  10732. // :fparam name='hwnd' type='HWND' io='input' .
  10733. // Handle of the droppee window.
  10734. // :freturns.
  10735. // :fparam name='-' type='VOID' io='-'.
  10736. // Nothing
  10737. // :efparams.
  10738. // :remarks.
  10739. // :related.
  10740. // :epfunction.
  10741. //----------------------------------------------------------------------------
  10742. VOID _Optlink UCMenuRemoveDropEmphasis( PUCMDATA UCMData, HWND hwnd )
  10743. {
  10744.    RECTL    rcl;
  10745.    BOOL     fSuccess, fSuccess2;
  10746.    MENUITEM mi;
  10747.  
  10748.    fSuccess  = (BOOL) WinSendMsg( hwnd,
  10749.                                   MM_QUERYITEMRECT,
  10750.                                   MPFROM2SHORT( UCMData->TargetID, TRUE ),
  10751.                                   MPFROMP( &rcl ) );
  10752.    fSuccess2 = (BOOL) WinSendMsg( hwnd,
  10753.                                   MM_QUERYITEM,
  10754.                                   MPFROM2SHORT( UCMData->TargetID, TRUE ),
  10755.                                   MPFROMP( &mi ) );
  10756.  
  10757.    if ( fSuccess && fSuccess2 ){
  10758.       ULONG ColorIndex;
  10759.       HPS hps   = DrgGetPS( hwnd );
  10760.  
  10761.       if (WinIsMenuItemChecked(hwnd,UCMData->TargetID)) {
  10762.          ColorIndex = CLR_BLACK;
  10763.       } else if ( mi.afStyle & MIS_SPACER ){
  10764.          ColorIndex = UCMenuSelectColor( UCMData->BgColor, hps );
  10765.       } else {
  10766.          ColorIndex = UCMenuSelectColor( UCMData->ItemBgColor, hps );
  10767.       } // endif
  10768.  
  10769.       rcl.xLeft   += 1;
  10770.       rcl.yBottom += 1;
  10771.       rcl.yTop    -= 1;
  10772.       rcl.xRight  -= 1;
  10773.  
  10774.       WinDrawBorder( hps, &rcl, 1, 1, ColorIndex, 0, DB_PATCOPY);
  10775.       DrgReleasePS( hps );
  10776.    } // endif
  10777.    UCMData->TargetID = 0;
  10778. }
  10779.  
  10780. //----------------------------------------------------------------------------
  10781. // UCMenuDragOver : not for the user's doc
  10782. //----------------------------------------------------------------------------
  10783. // :pfunction res=&IDF_DRGOVER. name='UCMenuDragOver' text='Called when a ucmenu is dragged over'.
  10784. // This function is called whenever something is being dragged over a ucmenu.
  10785. // :syntax name='UCMenuDragOver' params='hwnd, pDragInfo' return='rc'.
  10786. // :fparams.
  10787. // :fparam name='hwnd' type='HWND' io='input' .
  10788. // Handle of the droppee window (menu, submenu or hide).
  10789. // :fparam name='pDragInfo' type='PDRAGINFO' io='input' .
  10790. // Pointer to the draginfo structure
  10791. // :freturns.
  10792. // :fparam name='rc' type='MRESULT' io='return'.
  10793. // Return code for a PM DM_DRAGOVER message
  10794. // :efparams.
  10795. // :remarks.
  10796. // :related.
  10797. // :epfunction.
  10798. //----------------------------------------------------------------------------
  10799. MRESULT _Optlink UCMenuDragOver(PUCMDATA UCMData, HWND hwnd, PDRAGINFO pDraginfo)
  10800. {
  10801.  USHORT        usOperation, usIndicator;
  10802.  PDRAGITEM     pditem;
  10803.  ULONG         ulStyle = UCMData->Style;
  10804.  PUCMDATA      UCMDataSource;
  10805.  ULONG         ulStyleSource = 0;
  10806.  BOOL          bSameProcess;
  10807.  BOOL          IsUCMenu = FALSE;    // Source of drag is a UCMenu control
  10808.  PID           pidSource, pid;
  10809.  TID           tid;
  10810.  
  10811.  // -------------------------------------------------------------------------
  10812.  // -- In case we refuse, we answer only DOR_NODROP, not DOR_NEVERDROP or
  10813.  // -- DOR_NODROPOP, because it would prevent DM_DRAGOVER from being sent to
  10814.  // -- the menu, and we need it all the time in order to draw the drop
  10815.  // -- emphasis on the items (the items are not actual windows).
  10816.  // -------------------------------------------------------------------------
  10817.  
  10818.  // ------------------------------------------
  10819.  // -- First check if drag and drop is allowed
  10820.  // ------------------------------------------
  10821.  if ( UCMData->Style & UCS_NO_DM ) {
  10822.     return MPFROM2SHORT( DOR_NODROP, 0 );
  10823.  } // endif
  10824.  
  10825.  /* ---------------------------------------------------------------------- */
  10826.  /* Get access to the DRAGINFO structure.                                  */
  10827.  /* ---------------------------------------------------------------------- */
  10828.  DrgAccessDraginfo (pDraginfo);
  10829.  pditem = DrgQueryDragitemPtr (pDraginfo, 0);
  10830.  
  10831.  WinQueryWindowProcess( hwnd, &pid, &tid );
  10832.  WinQueryWindowProcess( pDraginfo->hwndSource, &pidSource, &tid );
  10833.  
  10834.  //(MAM) fixed terrible assumption that if drag was from another window in
  10835.  //      the same process, it must be a drag from another UCMenu.  Caused
  10836.  //      trap/hang if application has its own drag/drop implementation in
  10837.  //      addition to a UCMenu.
  10838.  
  10839.  bSameProcess = ( pid == pidSource );
  10840.  if ( bSameProcess ){
  10841.     HWND Owner;
  10842.     char Class[20] = "";
  10843.  
  10844.     // Check class name of source window... get UCMData of source only
  10845.     // if it is really a UCMenu window.  Check by looking at owner
  10846.     // of source window (menu or submenu).
  10847.  
  10848.     Owner = WinQueryWindow(pDraginfo->hwndSource, QW_OWNER);
  10849.     WinQueryClassName(Owner, sizeof(Class), Class);
  10850.     if (!strcmp(Class, UCMCLASS))
  10851.       IsUCMenu = TRUE;
  10852.     else {
  10853.       Owner = WinQueryWindow(Owner, QW_OWNER);
  10854.       WinQueryClassName(Owner, sizeof(Class), Class);
  10855.       if (!strcmp(Class, UCMCLASS))
  10856.         IsUCMenu = TRUE;
  10857.     }
  10858.  
  10859.     if (IsUCMenu) {
  10860.       UCMDataSource = (PUCMDATA) WinQueryWindowULong( pDraginfo->hwndSource, QWL_USER);
  10861.       ulStyleSource = UCMDataSource->Style;
  10862.     }
  10863.  } /* endif */
  10864.  
  10865.  /* ---------------------------------------------------------------------- */
  10866.  /* Determine if a drop can be accepted                                    */
  10867.  /* ---------------------------------------------------------------------- */
  10868.  usIndicator = DOR_DROP;
  10869.  if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 ){
  10870.     pDraginfo->usOperation = DO_UNKNOWN;
  10871.  } // endif
  10872.  usOperation = pDraginfo->usOperation;
  10873.  switch (pDraginfo->usOperation) {
  10874.    case DO_COPY:
  10875.      usOperation = DO_COPY;
  10876.      break;
  10877.    case DO_MOVE:
  10878.      usOperation = DO_MOVE;
  10879.      break;
  10880.    case DO_DEFAULT:
  10881.      {
  10882.         if ( !bSameProcess ) {
  10883.            usOperation = DO_COPY;
  10884.         } else if (  DrgVerifyRMF (pditem, "DRM_UCMITEM",  "DRF_UNKNOWN") ){
  10885.            // At this point we are sure that the process is the same for
  10886.            // source and target so it makes sense to compare the PUCMDATA
  10887.            // pointers to know whether we are in the same ucmenu or not
  10888.            if ( ( ulStyleSource & UCS_NO_DM_M_TO_OTHER ) && ( UCMData != UCMDataSource ) ) {
  10889.               usOperation = DO_COPY;
  10890.            } else {
  10891.               usOperation = DO_MOVE;
  10892.            } /* endif */
  10893.         } else if( DrgVerifyRMF(pditem, "DRM_OS2FILE", "DRF_TEXT") )  {
  10894.            usOperation = DO_COPY;
  10895.         } // endif
  10896.      }
  10897.      break;
  10898.    case DO_UNKNOWN:
  10899.       {
  10900.  
  10901.          usIndicator = DOR_NODROP;
  10902.  
  10903.          if ( !( UCMData->Style & UCS_NO_DM_ALT ) ){
  10904.             POINTL ptlPos;
  10905.             USHORT usItemid;
  10906.             ptlPos.x = pDraginfo->xDrop;
  10907.             ptlPos.y=  pDraginfo->yDrop;
  10908.             WinMapWindowPoints(HWND_DESKTOP, UCMData->hwndMenu, &ptlPos, 1);
  10909.             usItemid = UCMenuIdFromCoord( UCMData->hwndMenu, &ptlPos );
  10910.             if ( usItemid ){
  10911.                MENUITEM mi;
  10912.                memset( &mi, '\0', sizeof mi );
  10913.                if ( WinSendMsg( UCMData->hwndMenu,
  10914.                                 MM_QUERYITEM,
  10915.                                 MPFROM2SHORT( usItemid, FALSE ),
  10916.                                MPFROMP( &mi ) )
  10917.                     && !( mi.afStyle & MIS_SPACER ) ){
  10918.                   // We only accept alt drops over non spacer or non static items
  10919.                   // We also don't want alt drop over the hide window (in this case usItemid will be 0)
  10920.                   usIndicator = DOR_DROP;
  10921.                   usOperation = DO_COPY; // We will get a DO_UNKNOWN anyway in DM_DROP !!
  10922.                } // endif
  10923.             } // endif
  10924.          } // endif
  10925.       }
  10926.       break;
  10927.   default:
  10928.      usIndicator = DOR_NODROP;
  10929.      usOperation = 0;
  10930.  } // endswitch
  10931.  
  10932.  // --------------------------------------------------------------------------------
  10933.  // -- In order to support the drop, the source must support  a rendering
  10934.  // --  mechanims of <DRM_UCMENU,DRF_UNKNOWN> or <DRM_OS2FILE,DRF_UNKNOWN>
  10935.  // --  We also check the UCS_ flags  to know if the requested operation is allowed
  10936.  // --------------------------------------------------------------------------------
  10937.  if ( DrgVerifyRMF (pditem, "DRM_UCMITEM",  "DRF_UNKNOWN") ){
  10938.     //(MAM) source may be a submenu of this UCM, need OR conditition
  10939.     BOOL bSameUCM = (UCMData->hwndMenu==pDraginfo->hwndSource)||
  10940.                     (UCMData->hwndMenu==WinQueryWindow(pDraginfo->hwndSource, QW_OWNER));
  10941.     BOOL bMove    = (usOperation == DO_MOVE); // else it is a copy
  10942.  
  10943.  
  10944.     if ( bSameUCM && ( !bMove && ulStyle&UCS_NO_DM_C_INSIDE
  10945.                      || bMove && ulStyle&UCS_NO_DM_M_INSIDE )
  10946.      || !bSameUCM && ( !bMove && ( ulStyle&UCS_NO_DM_C_FROM_OTHER || ulStyleSource&UCS_NO_DM_C_TO_OTHER )
  10947.                      || bMove && ( ulStyle&UCS_NO_DM_M_FROM_OTHER || ulStyleSource&UCS_NO_DM_M_TO_OTHER ) ) ) {
  10948.        usIndicator = DOR_NODROP;
  10949.     } // endif
  10950.  } else if (  DrgVerifyRMF( pditem, "DRM_OS2FILE", "DRF_TEXT" )
  10951.            && DrgVerifyType( pditem, DRT_BITMAP ) )  {
  10952.     if ( UCMData->Style&UCS_NO_DM_RENDER_FROM_BMP ) {
  10953.        usIndicator = DOR_NODROP;
  10954.     } // endif
  10955.  } else {
  10956.     usIndicator = DOR_NODROP;
  10957.  } // endif
  10958.  
  10959.  
  10960.  DrgFreeDraginfo (pDraginfo);
  10961.  
  10962.  return (MRFROM2SHORT(usIndicator, usOperation));
  10963. }
  10964.  
  10965. //--------------------------------------------------------------------------//
  10966. //------------------------------- DROP CODE --------------------------------//
  10967. //--------------------------------------------------------------------------//
  10968. //----------------------------------------------------------------------------
  10969. // UCMenuDrop : not for the user's doc
  10970. //----------------------------------------------------------------------------
  10971. // :pfunction res=&IDF_DROP. name='UCMenuDrop' text='Called when something is dropped on a ucmenu'.
  10972. // This function is called whenever something is dropped on a ucmenu.
  10973. // :syntax name='UCMenuDrop' params='hwnd, pDragInfo' return='-'.
  10974. // :fparams.
  10975. // :fparam name='hwnd' type='HWND' io='input'.
  10976. // Handle of the window receiving the drop.
  10977. // :fparam name='pDragInfo' type='PDRAGINFO' io='input' .
  10978. // Pointer to the draginfo structure
  10979. // :freturns.
  10980. // :fparam name='-' type='VOID' io='-'.
  10981. // Nothing
  10982. // :efparams.
  10983. // :remarks.
  10984. // :related.
  10985. // :epfunction.
  10986. //----------------------------------------------------------------------------
  10987. VOID  _Optlink UCMenuDrop(HWND hwnd, PDRAGINFO pDraginfo)
  10988. {
  10989.    PDRAGITEM     pditem;
  10990.    TID           tid;
  10991.    PID           pidSource, pidTarget;
  10992.    BOOL          bAlt;
  10993.    PUCMDATA      UCMData = (PUCMDATA) WinQueryWindowULong( hwnd, QWL_USER );
  10994.  
  10995.  
  10996.    // ----------------------------------------------------------------------------
  10997.    // -- If we are on any window other than a submenu, pretend we are on the menu
  10998.    // ----------------------------------------------------------------------------
  10999.    if (WinQueryWindow( hwnd, QW_OWNER ) != UCMData->hwndMenu) {
  11000.       hwnd = UCMData->hwndMenu;
  11001.    } // endif
  11002.  
  11003.  
  11004.    UCMenuRemoveDropEmphasis( UCMData, hwnd);
  11005.  
  11006.  
  11007.    DrgAccessDraginfo (pDraginfo);
  11008.   
  11009.    // ----------------------------------------------------------------------------
  11010.    // -- Set up a flag to know whether ALT was pressed or not
  11011.    // ----------------------------------------------------------------------------
  11012.    if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 ){
  11013.       // !! If alt was pressed before beginning the drag, usOperation will be DO_MOVE !!
  11014.       pDraginfo->usOperation = DO_UNKNOWN;
  11015.       bAlt = TRUE;
  11016.    } else {
  11017.       bAlt = FALSE;
  11018.    } // endif
  11019.   
  11020.    if (!WinQueryWindowProcess( hwnd, &pidTarget, &tid )) {
  11021.       pidTarget = 0;
  11022.    } // endif
  11023.   
  11024.    if (!WinQueryWindowProcess( pDraginfo->hwndSource, &pidSource, &tid )) {
  11025.       pidSource = 0;
  11026.    } // endif
  11027.   
  11028.    pditem = DrgQueryDragitemPtr (pDraginfo, 0);
  11029.    if ( pditem ) {
  11030.      /* ---------------------------------------------------------------------- */
  11031.      /* Let's render                                                           */
  11032.      /* ---------------------------------------------------------------------- */
  11033.      /* We assume only one object is being dragged                             */
  11034.      /* ---------------------------------------------------------------------- */
  11035.      PDRAGTRANSFER   pDxfer;
  11036.      PVOID           pSharedMem;
  11037.      BOOL            bFullItemDropped;
  11038.      BOOL            bRenderSuccess = TRUE;
  11039.   
  11040.      // -- We ask the source to render
  11041.      pDxfer = DrgAllocDragtransfer(1);
  11042.      pDxfer->cb               = sizeof(DRAGTRANSFER);
  11043.      pDxfer->hwndClient       = hwnd;
  11044.      pDxfer->pditem           = pditem;
  11045.      pDxfer->hstrRenderToName = 0;
  11046.      pDxfer->usOperation      = pDraginfo->usOperation;
  11047.      pDxfer->fsReply          = 0;
  11048.      pDxfer->ulTargetInfo     = 0;
  11049.   
  11050.      if (DrgVerifyRMF( pditem, "DRM_UCMITEM", "DRF_UNKNOWN" )){
  11051.         // ------------------------------------------------------------------------
  11052.         // -- We want a full ucmenu item
  11053.         // ------------------------------------------------------------------------
  11054.         pDxfer->hstrSelectedRMF  = DrgAddStrHandle("<DRM_UCMITEM,DRF_UNKNOWN>");
  11055.         // ------------------------------------------------------------------------
  11056.         // -- In case the source is in another process, allocate some shared mem
  11057.         // ------------------------------------------------------------------------
  11058.         if (pidSource!=pidTarget) {
  11059.            // ------------------------------------------------------------------------
  11060.            // -- We will store in that mem the MENUITEM and UCMITEM structures
  11061.            // -- associated to an item, so one page (4K) should be enough
  11062.            // -- (We will use DosSubAllocMem, which has a granularity of 8 bytes and not 4096)
  11063.            // ------------------------------------------------------------------------
  11064.            DosAllocSharedMem( &pSharedMem, 0, 4000, PAG_READ | PAG_WRITE |  PAG_COMMIT | OBJ_GIVEABLE );
  11065.            DosSubSetMem( pSharedMem, DOSSUB_INIT, 4000 );
  11066.            DosGiveSharedMem( pSharedMem, pidSource, PAG_READ | PAG_WRITE );
  11067.            pDxfer->ulTargetInfo = (ULONG)pSharedMem;
  11068.         } // endif
  11069.         bFullItemDropped = TRUE;
  11070.      } else {
  11071.         // ------------------------------------------------------------------------
  11072.         // -- We are sure that this RMF is supported because of the DM_DRAGOVER processing
  11073.         // -- We will make a new ucmenu item using this bitmap
  11074.         // ------------------------------------------------------------------------
  11075.         pDxfer->hstrSelectedRMF = DrgAddStrHandle("<DRM_OS2FILE,DRF_TEXT>");
  11076.         bFullItemDropped = FALSE;
  11077.      } // endif
  11078.   
  11079.      // ------------------------------------------------------------------------
  11080.      // -- If it is a ucmenu item, we always ask the rendering
  11081.      // --   (because we render differently if the processes are not the same)
  11082.      // -- If it is a bmp file, we ask the rendering only if the filename is not provided.
  11083.      // ------------------------------------------------------------------------
  11084.      if ( bFullItemDropped || !pditem->hstrSourceName ) {
  11085.         bRenderSuccess = (BOOL)DrgSendTransferMsg( pDraginfo->hwndSource,
  11086.                                                    DM_RENDER,
  11087.                                                    (MPARAM)pDxfer,
  11088.                                                    (MPARAM)0 );
  11089.      } else {
  11090.         // ----------------------------------------------------------------
  11091.         // -- Bmp file whose name is provided : we can render by ourselves.
  11092.         // ----------------------------------------------------------------
  11093.         DrgDeleteStrHandle( pDxfer->hstrSelectedRMF );
  11094.      } // endif
  11095.   
  11096.      /* We must always free the drag xfer structure.  Target of DM_RENDER */
  11097.      /* must also free it because DrgSendTransferMsg() does a DosGive()   */
  11098.      /* to the target process but not DosFree().                          */
  11099.      DrgFreeDragtransfer( pDxfer );
  11100.   
  11101.      if ( bRenderSuccess ) {
  11102.         MENUITEM * pMiNew;
  11103.         HWND       hwndDest;
  11104.         POINTL     ptlPos;
  11105.         USHORT     usItemid;    // ID of the target item
  11106.         SHORT      sIndex;      // Index used to insert the item
  11107.         PSZ        pszRenderInfo;
  11108.         ULONG      ul;
  11109.   
  11110.         // -------------------------------------------------------
  11111.         // -- Decide which window will handle the item insertion
  11112.         // -------------------------------------------------------
  11113.         if ( WinQueryWindow( hwnd, QW_OWNER ) != UCMData->hwndMenu ){
  11114.            // -- If we are not on a submenu, the ucmenu will do the insertion
  11115.            hwndDest = WinQueryWindow( hwnd, QW_OWNER );
  11116.         } else {
  11117.            // -- If we are on a submenu, it can handle the insert by itself
  11118.            hwndDest = hwnd;
  11119.         } // endif
  11120.   
  11121.   
  11122.         // ----------------------------------------------------------------------------
  11123.         // -- Get the rendered information
  11124.         // ----------------------------------------------------------------------------
  11125.         ul = DrgQueryStrNameLen(pditem->hstrSourceName) + 1;
  11126.         pszRenderInfo = (PSZ)MyMalloc(ul);
  11127.         DrgQueryStrName(pditem->hstrSourceName,    // string handle
  11128.                         ul,                        // Nb of bytes
  11129.                         pszRenderInfo);            // buffer
  11130.   
  11131.         // ----------------------------------------------------------------------------
  11132.         // -- Use the rendered info to fill in the MENUITEM
  11133.         // ----------------------------------------------------------------------------
  11134.         {
  11135.            pMiNew = MyMalloc( sizeof(MENUITEM) );
  11136.            memset(pMiNew, 0, sizeof(MENUITEM));
  11137.            if ( bFullItemDropped ) {
  11138.   
  11139.               MENUITEM * pMiTransfered = 0;
  11140.   
  11141.               sscanf(pszRenderInfo, "%u", &pMiTransfered);
  11142.               pMiNew->iPosition   = pMiTransfered->iPosition;
  11143.               pMiNew->afStyle     = pMiTransfered->afStyle;
  11144.               pMiNew->afAttribute = pMiTransfered->afAttribute;
  11145.               pMiNew->id          = pMiTransfered->id;
  11146.               pMiNew->hwndSubMenu = pMiTransfered->hwndSubMenu;
  11147.               if ( pMiTransfered->hItem ){
  11148.                  pMiNew->hItem = (ULONG)MyMalloc(sizeof(UCMITEM));
  11149.                  memset((PVOID)pMiNew->hItem, 0, sizeof(UCMITEM));
  11150.                  ITEM(pMiNew, hBmp)    = ITEM(pMiTransfered, hBmp);
  11151.                  ITEM(pMiNew, pszBmp)  = MyStrdup( ITEM(pMiTransfered, pszBmp) );
  11152.                  ITEM(pMiNew, pszText) = MyStrdup( ITEM(pMiTransfered, pszText) );
  11153.                  ITEM(pMiNew, pszAction) = MyStrdup( ITEM(pMiTransfered, pszAction) );
  11154.                  ITEM(pMiNew, pszParameters) = MyStrdup( ITEM(pMiTransfered, pszParameters) );
  11155.                  ITEM(pMiNew, pszData) = MyStrdup( ITEM(pMiTransfered, pszData) );
  11156.               }
  11157.               if (pidSource==pidTarget) {
  11158.                  // -- Same process -> the transfered item has been allocated with MyMalloc
  11159.                  // -- Else, it is in shared mem, the whole shared mem bank will be freed
  11160.                  // --  at the end of UCMenuDrop
  11161.                  MyFree( pMiTransfered );
  11162.               } // endif
  11163.            } else {
  11164.               // -- We have here a bitmap file name
  11165.               ULONG ul2;
  11166.   
  11167.               pMiNew->hItem = (ULONG)MyMalloc(sizeof(UCMITEM));
  11168.               memset((PVOID)pMiNew->hItem, 0, sizeof(UCMITEM));
  11169.   
  11170.               ul2 = DrgQueryStrNameLen(pditem->hstrContainerName)+1;
  11171.               ((UCMITEM*)pMiNew->hItem)->pszBmp = MyMalloc(ul+ul2);
  11172.               DrgQueryStrName( pditem->hstrContainerName, ul2, ITEM(pMiNew,pszBmp));
  11173.               strcat( ITEM(pMiNew,pszBmp), pszRenderInfo );
  11174.               pMiNew->afStyle = MIS_OWNERDRAW;
  11175.            } // endif
  11176.         }
  11177.   
  11178.         // ----------------------------------------------------------------------------
  11179.         // -- Force the reloading of the bitmap if necessary
  11180.         // ----------------------------------------------------------------------------
  11181.         if ( pMiNew->hItem &&
  11182.             ( pidSource!=pidTarget || pDraginfo->usOperation==DO_COPY || pDraginfo->usOperation==DO_UNKNOWN ) ) {
  11183.            // ----------------------------------
  11184.            // -- Release the bitmap if necessary
  11185.            // ----------------------------------
  11186.            if ( ITEM(pMiNew,hBmp) &&
  11187.                 (pidSource!=pidTarget) &&
  11188.                 (pDraginfo->usOperation==DO_MOVE) ){
  11189.               GpiDeleteBitmap( ITEM(pMiNew,hBmp) );
  11190.            } // endif
  11191.            ITEM(pMiNew,hBmp) = 0;
  11192.         } // endif
  11193.   
  11194.         // -----------------------------------------------------------------------------
  11195.         // -- (MAM) remove any MIS_BREAK
  11196.         // -----------------------------------------------------------------------------
  11197.         pMiNew->afStyle &= (USHORT) ~MIS_BREAK;
  11198.   
  11199.         // ----------------------------------------------------------------------------
  11200.         // -- Query where the item has to be dropped (index in the menu)
  11201.         // ----------------------------------------------------------------------------
  11202.         ptlPos.x = pDraginfo->xDrop;
  11203.         ptlPos.y=  pDraginfo->yDrop;
  11204.         WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptlPos, 1);
  11205.         usItemid = UCMenuIdFromCoord(hwnd, &ptlPos);
  11206.         if (usItemid) {
  11207.            RECTL    rect;
  11208.            if ( bAlt && ( hwnd == UCMData->hwndMenu ) ){
  11209.               MENUITEM mi;
  11210.               WinSendMsg( hwnd,
  11211.                           MM_QUERYITEM,
  11212.                           MPFROM2SHORT( usItemid, FALSE ), 
  11213.                           MPFROMP( &mi ) );
  11214.   
  11215.               if ( !( mi.afStyle & MIS_SUBMENU ) ){
  11216.               
  11217.                  mi.afStyle |= MIS_SUBMENU;
  11218.                  mi.hwndSubMenu = WinCreateWindow( HWND_OBJECT,
  11219.                                                    WC_MENU,
  11220.                                                    "",
  11221.                                                    0, // WS_*
  11222.                                                    0,
  11223.                                                    0,
  11224.                                                    0,
  11225.                                                    0,
  11226.                                                    UCMData->hwndMenu,
  11227.                                                    HWND_BOTTOM,
  11228.                                                    usItemid,
  11229.                                                    0,
  11230.                                                    0 );
  11231.                 WinSendMsg( WinQueryWindow( UCMData->hwndMenu, QW_OWNER ),  // ucmenu window
  11232.                             MM_SETITEM,
  11233.                             MPFROM2SHORT( usItemid, FALSE ), 
  11234.                             MPFROMP( &mi ) );
  11235.               } // endif
  11236.   
  11237.               hwndDest = hwnd = mi.hwndSubMenu;
  11238.            } // endif
  11239.   
  11240.            sIndex = (SHORT)WinSendMsg( hwnd,
  11241.                                        MM_ITEMPOSITIONFROMID,
  11242.                                        MPFROM2SHORT(usItemid, FALSE), 
  11243.                                        (MPARAM)0 );
  11244.            // -------------------------------------------------------------------------------------
  11245.            // -- If it is an item of a vertical ucmenu or of a submenu of an horizontal ucmenu, we
  11246.            // --  put the dropped item before if it is dropped over the top half and after else.
  11247.            // -- If it is an item of an horizontal ucmenu or of a submenu of a vertical ucmenu, we
  11248.            // --  put the dropped item before if it is dropped over the left half and after else.
  11249.            // -- A matrix ucmenu is here processed in the same way as an horizontal one.
  11250.            // -------------------------------------------------------------------------------------
  11251.            if ( WinSendMsg( hwnd, MM_QUERYITEMRECT, MPFROM2SHORT( usItemid, FALSE ), MPFROMP( &rect ) ) ) { 
  11252.               HWND hwndUCMDest = WinQueryWindow( hwnd, QW_OWNER );
  11253.               ULONG Style      = WinQueryWindowULong( hwndUCMDest, QWL_STYLE );
  11254.               if (   ( (Style & CMS_VERT) && (hwnd == UCMData->hwndMenu))  ||
  11255.                      (!(Style & CMS_VERT) && (hwnd != UCMData->hwndMenu)) ) {
  11256.                        if ( ptlPos.y < (rect.yTop+rect.yBottom)/2)
  11257.                          sIndex++;
  11258.               } else {
  11259.                  if ( ptlPos.x > (rect.xRight+rect.xLeft)/2) 
  11260.                    sIndex++;
  11261.               } // endif Style...
  11262.            } // endif WinSendMsg
  11263.   
  11264.         } else {
  11265.            sIndex = MIT_LAST;
  11266.         } // endif
  11267.   
  11268.         if (sIndex==MIT_LAST || sIndex==MIT_NONE) {
  11269.           // -------------------------------------------------------
  11270.           // -- Query item count : item insert after all the others
  11271.           // -------------------------------------------------------
  11272.           sIndex = (SHORT)WinSendMsg(hwnd,
  11273.                                      MM_QUERYITEMCOUNT,
  11274.                                      (MPARAM)0,
  11275.                                      (MPARAM)0);
  11276.         } // endif
  11277.   
  11278.         // -----------------------------------------------------------------------
  11279.         // -- Before dropping, we unselect all the items of the dest menu
  11280.         // -- because the open submenu of a nodismiss submenu item do not follow
  11281.         // -- it when this item is moved
  11282.         // -----------------------------------------------------------------------
  11283.         UCMenuUnselectAll( UCMData->hwndMenu );
  11284.   
  11285.         switch (pDraginfo->usOperation) {
  11286.           case DO_UNKNOWN:
  11287.              // This is for the Alt dropping
  11288.           case DO_COPY:
  11289.             {
  11290.                // --------------------------------------------------------------------------------
  11291.                // -- If dropped item was a submenu placeholder, turn it into a regular item.
  11292.                // --------------------------------------------------------------------------------
  11293.                pMiNew->afStyle     &= (USHORT)~MIS_SUBMENU;
  11294.                //(MAM) also remove NODISMISS attribute
  11295.                pMiNew->afAttribute &= (USHORT)~MIA_NODISMISS;
  11296.                pMiNew->hwndSubMenu  = NULLHANDLE;
  11297.                pMiNew->iPosition    = sIndex;
  11298.                pMiNew->id           = UCMenuGetNewID( UCMData->hwndMenu, MIT_NONE, UCMData );
  11299.   
  11300.                WinSendMsg(hwndDest,
  11301.                           MM_INSERTITEM,
  11302.                           MPFROMP(pMiNew),
  11303.                           (MPARAM)0);
  11304.   
  11305.             }
  11306.             break;
  11307.   
  11308.           case DO_MOVE:
  11309.             { SHORT sSourcePos    = pMiNew->iPosition;
  11310.               USHORT SourceMenuID = pMiNew->id;
  11311.   
  11312.               if ( ( pMiNew->hwndSubMenu && ( hwnd != UCMData->hwndMenu ) )
  11313.                    || pidSource!=pidTarget ){
  11314.                  // --------------------------------------------------------------------------
  11315.                  // -- Only one submenu level is supported
  11316.                  // -- If we move an item with a submenu into another one, we remove its submenu
  11317.                  // -- We don't move the submenus from other apps because it's too complicated...
  11318.                  // --------------------------------------------------------------------------
  11319.                  UCMenuFreeMenuData( pMiNew->hwndSubMenu );
  11320.                  WinDestroyWindow( pMiNew->hwndSubMenu );
  11321.                  pMiNew->afStyle    &= (USHORT)~MIS_SUBMENU; // turn into a normal item if submenu holder
  11322.                  pMiNew->afAttribute&= (USHORT)~MIA_NODISMISS;
  11323.                  pMiNew->hwndSubMenu = 0;
  11324.               } // endif
  11325.   
  11326.               if ( pditem->hwndItem == hwnd ) {
  11327.                 // --------------------------------------------------------------------------
  11328.                 // -- Same destination : the item interferes with its index
  11329.                 // --------------------------------------------------------------------------
  11330.                 if (sSourcePos<sIndex) {
  11331.                   pMiNew->iPosition = sIndex - 1;
  11332.                 } else {
  11333.                   pMiNew->iPosition = sIndex;
  11334.                 } // endif
  11335.               } else {
  11336.                 // --------------------------------------------------------------------------
  11337.                 // -- Different UCMenus : we need a new ID !
  11338.                 // --------------------------------------------------------------------------
  11339.                 pMiNew->id        = UCMenuGetNewID( UCMData->hwndMenu, MIT_NONE, UCMData );
  11340.                 pMiNew->iPosition = sIndex;
  11341.               } // endif
  11342.   
  11343.               if ( bFullItemDropped ) {
  11344.                  // --------------------------------------------------------------------------
  11345.                  // -- The dropped object was coming from a ucmenu
  11346.                  // --------------------------------------------------------------------------
  11347.                  if ( pidSource == pidTarget) {
  11348.                     MENUITEM mi;
  11349.                     WinSendMsg( pDraginfo->hwndSource,
  11350.                                 MM_QUERYITEM,
  11351.                              // (MAM) source may have been a submenu item, so we need
  11352.                              //       to search submenus also.
  11353.                              // MPFROM2SHORT( SourceMenuID, FALSE ),
  11354.                                 MPFROM2SHORT( SourceMenuID, TRUE  ),
  11355.                                 MPFROMP( &mi ) );
  11356.                     if ( mi.hItem ) {
  11357.                        if ( ITEM( &mi, pszBmp ) ){    MyFree( ITEM( &mi, pszBmp ) ); }
  11358.                        if ( ITEM( &mi, pszText ) ){   MyFree( ITEM( &mi, pszText ) ); }
  11359.                        if ( ITEM( &mi, pszAction ) ){ MyFree( ITEM( &mi, pszAction ) ); }
  11360.                        if ( ITEM( &mi, pszParameters ) ){ MyFree( ITEM( &mi, pszParameters ) ); }
  11361.                        if ( ITEM( &mi, pszData ) ){   MyFree( ITEM( &mi, pszData ) ); }
  11362.                     } // endif
  11363.                     WinSendMsg(WinQueryWindow(pDraginfo->hwndSource, QW_OWNER),
  11364.                                MM_REMOVEITEM,
  11365.                             // (MAM) Source item may have been a submenu, so we
  11366.                             //       need TRUE here to delete submenu source items.  This
  11367.                             //       is safe since all UCMenu item IDs should be unique.
  11368.                             // MPFROM2SHORT(SourceMenuID, FALSE),
  11369.                                MPFROM2SHORT(SourceMenuID, TRUE),
  11370.                                (MPARAM)0);
  11371.                  } else {
  11372.                     WinSendMsg(WinQueryWindow(pDraginfo->hwndSource, QW_OWNER),
  11373.                                MM_DELETEITEM,
  11374.                             // (MAM) Source item may have been a submenu, so we
  11375.                             //       need TRUE here to delete submenu source items.  This
  11376.                             //       is safe since all UCMenu item IDs should be unique.
  11377.                             // MPFROM2SHORT(SourceMenuID, FALSE),
  11378.                                MPFROM2SHORT(SourceMenuID, TRUE),
  11379.                                (MPARAM)0);
  11380.                  } // endif
  11381.               }
  11382.   
  11383.               WinSendMsg(hwndDest,
  11384.                          MM_INSERTITEM,
  11385.                          MPFROMP( pMiNew ),
  11386.                          (MPARAM)0 );
  11387.             } break;
  11388.           default:
  11389.             //-- invalid operation
  11390.             break;
  11391.         } // endswitch
  11392.         // ----------------------------------------------------------------------------------------
  11393.         // -- We can now free pMiNew, it was either allocated by us or by the source using MyMalloc
  11394.         // ----------------------------------------------------------------------------------------
  11395.         MyFree( pMiNew );
  11396.      } // endif render successful
  11397.   
  11398.   
  11399.      // ----------------------------------------------------------------------------------------
  11400.      // -- Now let's notify the source that it can release the resources it allocated for the rendering.
  11401.      // ----------------------------------------------------------------------------------------
  11402.      DrgSendTransferMsg( pDraginfo->hwndSource,
  11403.                          DM_ENDCONVERSATION,
  11404.                          (MPARAM)pditem->ulItemID,
  11405.                          (MPARAM)DMFL_TARGETSUCCESSFUL);
  11406.   
  11407.   
  11408.      // ---------------------------------------------------------------------------------------
  11409.      // -- If we did allocate shared memory, free it
  11410.      // ---------------------------------------------------------------------------------------
  11411.      if ( bFullItemDropped && pidSource!=pidTarget ) {
  11412.         DosSubUnsetMem( pSharedMem );
  11413.         DosFreeMem( pSharedMem );
  11414.      } // endif
  11415.   
  11416.    } // endif  pditem
  11417.   
  11418.    // ---------------------------------------------------------------------------------------
  11419.    // -- free the resource:
  11420.    // ---------------------------------------------------------------------------------------
  11421.    DrgDeleteDraginfoStrHandles (pDraginfo);
  11422.    DrgFreeDraginfo (pDraginfo);
  11423. }
  11424.  
  11425. //----------------------------------------------------------------------------
  11426. // UCMenuPresParamChanged : not for the user's doc
  11427. //----------------------------------------------------------------------------
  11428. // :pfunction res=&IDF_PPCHG. name='UCMenuPresParamChanged' text='Processes the presentation parameter changes'.
  11429. // This function is called within the WM_PRESPARAMCHANGED processing.
  11430. // :syntax name='UCMenuPresParamChanged' params='hwndUCM, hwnd, mp1' return='-'.
  11431. // :fparams.
  11432. // :fparam name='hwndUCM' type='HWND' io='input'.
  11433. // Handle of the ucmenu
  11434. // :fparam name='hwnd' type='HWND' io='input'.
  11435. // Handle of the window which received WM_PRESPARAMCHANGED
  11436. // :p.It can be any of the windows part of a UCMenu.
  11437. // :fparam name='mp1' type='MPARAM' io='input' .
  11438. // First parameter of the WM_PRESPARAMCHANGED message
  11439. // :freturns.
  11440. // :fparam name='-' type='VOID' io='-'.
  11441. // Nothing
  11442. // :efparams.
  11443. // :remarks.
  11444. // :related.
  11445. // :epfunction.
  11446. //----------------------------------------------------------------------------
  11447. VOID _Optlink UCMenuPresParamChanged(PUCMDATA UCMData, HWND hwnd, MPARAM mp1)
  11448. {
  11449.    ULONG x;
  11450.  
  11451.    if ( (SHORT)mp1 == PP_BACKGROUNDCOLOR ) {
  11452.       ULONG Color;
  11453.  
  11454.       WinQueryPresParam( hwnd,
  11455.                          (SHORT)mp1,
  11456.                          0L, &x,
  11457.                          (ULONG)sizeof Color,
  11458.                          &Color,
  11459.                          QPF_NOINHERIT);
  11460.       if (x == (SHORT)mp1) {
  11461.          // We tell the menu to change its color
  11462.          // It will change UCMData->ItemBgColor and have everything redrawn
  11463.          WinSetPresParam( UCMData->hwndMenu,
  11464.                           PP_MENUBACKGROUNDCOLOR,
  11465.                           sizeof Color,
  11466.                           &Color);
  11467.       } else {
  11468.          WinRemovePresParam( hwnd, PP_BACKGROUNDCOLOR );
  11469.       } // endif
  11470.    } else if ( (SHORT)mp1 == PP_FONTNAMESIZE ) {
  11471.       CHAR FontNameSize[100];
  11472.  
  11473.       WinQueryPresParam( hwnd,
  11474.                          (SHORT)mp1,
  11475.                          0L, &x,
  11476.                          100L,
  11477.                          FontNameSize,
  11478.                          QPF_NOINHERIT );
  11479.       if (x == (SHORT)mp1) {
  11480.          // We remove this presparam from the window, because when the context
  11481.          // menu pops up, it uses the PP__FONTNAMESIZE font of its owner and we want
  11482.          // it to always use the default menu font. (its owner is the Hide window)
  11483.          WinRemovePresParam( hwnd, PP_FONTNAMESIZE );
  11484.          // We tell the menu to change its fonts
  11485.          // It will change UCMData->pszFontNameSize and have everything redrawn
  11486.          WinSetPresParam( UCMData->hwndMenu,
  11487.                           PP_FONTNAMESIZE,
  11488.                           strlen(FontNameSize)+1,
  11489.                           FontNameSize);
  11490.          // Tell bubble window about font changes
  11491.          if (UCMData->Style & UCS_BUBBLEHELP)
  11492.            WinSetPresParam( UCMData->hwndBubble,
  11493.                             PP_FONTNAMESIZE,
  11494.                             strlen(FontNameSize)+1,
  11495.                             FontNameSize);
  11496.       } else {
  11497.          WinRemovePresParam( hwnd, PP_FONTNAMESIZE );
  11498.       } // endif
  11499.  
  11500.    } // endif
  11501. }
  11502.  
  11503. //----------------------------------------------------------------------------
  11504. // UCMenuGetExePath : not for the user's doc
  11505. //----------------------------------------------------------------------------
  11506. // :pfunction res=&IDF_GETEXEPATH. name='UCMenuGetExePath' text='Finds the path of the program which called the dll'.
  11507. // This function returns the path of the exe file which called the ucmenu dll
  11508. // :syntax name='UCMenuGetExePath' params='-' return='pszPath'.
  11509. // :fparams.
  11510. // :freturns.
  11511. // :fparam name='pszPath' type='PSZ' io='return'.
  11512. // String containing the path
  11513. // :efparams.
  11514. // :remarks.
  11515. // :related.
  11516. // :epfunction.
  11517. //---------------------------------------------------------------------------
  11518. PSZ _Optlink UCMenuGetExePath(VOID)
  11519. {
  11520.   PTIB  ptib;
  11521.   PPIB  ppib = 0;
  11522.   ULONG rc;
  11523.   PSZ   psz = 0;
  11524.   rc = DosGetInfoBlocks(&ptib, &ppib);
  11525.   if (!rc) {
  11526.     CHAR sz[CCHMAXPATH];
  11527.     strcpy(sz, ppib->pib_pchcmd);
  11528.     strupr( sz );
  11529.     psz = strstr(sz, ".EXE");
  11530.     while (psz && (psz >= sz) && (*psz != '\\')) psz --;
  11531.     if (psz) {
  11532.       *psz = '\0';
  11533.       psz = MyStrdup(sz);
  11534.     } // endif
  11535.   } // endif
  11536.   return psz;
  11537. }
  11538.  
  11539. //----------------------------------------------------------------------------
  11540. // UCMenuGetBitmapPath : not for the user's doc
  11541. //----------------------------------------------------------------------------
  11542. // :pfunction res=&IDF_BMPPATH. name='UCMenuGetBitmapPath' text='Finds the path of the given bitmap file'.
  11543. // This function finds the access path of a given file.
  11544. // :syntax name='UCMenuGetBitmapPath' params='UCMData, pszBmp, pszPathName' return='success'.
  11545. // :fparams.
  11546. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11547. // Pointer to the UCMData structure
  11548. // :fparam name='pszBmp' type='PSZ' io='input'.
  11549. // String of the searched filename, which can also include a path and a drive
  11550. // :fparam name='pszPathName' type='MPARAM' io='output' .
  11551. // Full name of path found or "", must already be allocated to MAXPATHL characters
  11552. // :freturns.
  11553. // :fparam name='success' type='USHORT' io='return'.
  11554. // O if successful
  11555. // :efparams.
  11556. // :remarks.
  11557. // We look for the file (including any given path ) in the current directory, then we keep only the filename
  11558. // and look for it in the dir of the exe file, and in the path of the UCMData->pszBitmapSearchPath
  11559. // environment variables.
  11560. // :related.
  11561. // :epfunction.
  11562. //----------------------------------------------------------------------------
  11563. USHORT _Optlink UCMenuGetBitmapPath( PUCMDATA UCMData, PSZ pszBmp, PSZ pszPathName )
  11564. {
  11565.    PSZ   BitmapFile;
  11566.    UCHAR BitmapFileName[MAXPATHL];
  11567.    PSZ   Path;
  11568.    BOOL  FirstToken;
  11569.    UCHAR szBitmapSearchPath[MAXPATHL];
  11570.    ULONG DriveNumber, LogicalDriveMap;
  11571.    ULONG DirPathLen = MAXPATHL;
  11572.    BYTE DirPath[MAXPATHL];
  11573.    APIRET rc;
  11574.  
  11575.    // Query the current path
  11576.    // --
  11577.    rc =  DosQueryCurrentDisk( &DriveNumber, &LogicalDriveMap );
  11578.    rc += DosQueryCurrentDir( DriveNumber, DirPath, &DirPathLen );
  11579.  
  11580.    // Put in BitmapFileName the full access name of the given bitmap name in
  11581.    // the current drive and directory
  11582.    // --
  11583.    if ( pszBmp[1] == ':' && pszBmp[2] == '\\' ) {
  11584.       // The given filename includes the dir and path
  11585.       // --
  11586.       BitmapFileName[0] = '\0';
  11587.    } else  {
  11588.       // Add the default drive at the beginning
  11589.       // --
  11590.       BitmapFileName[0] = 'A' + DriveNumber - 1;
  11591.       BitmapFileName[1] = ':';
  11592.       BitmapFileName[2] = '\0';
  11593.       if ( pszBmp[0] != '\\' ) {
  11594.          // Add "\", current directory, and "\" before pszBmp;
  11595.          // --
  11596.          strcat( BitmapFileName, "\\" );
  11597.          strcat( BitmapFileName, DirPath );
  11598.          strcat( BitmapFileName, "\\" );
  11599.       }
  11600.    } // endif
  11601.    strcat( BitmapFileName, pszBmp );
  11602.  
  11603.    // Now BitmapFileName contains the full access name of the bitmap
  11604.    // We copy the directory part of it in DirPath
  11605.    // --
  11606.    BitmapFile = strrchr( BitmapFileName, '\\' );
  11607.    BitmapFile[0] = '\0';
  11608.    strcpy( DirPath, BitmapFileName );
  11609.    if ( ( DirPath[1] == ':' ) && ( DirPath[2] == '\0' ) ){
  11610.       // Drive only, we have to add \ else it will look
  11611.       // in the current directory of this drive
  11612.       // --
  11613.       strcat( DirPath, "\\" );
  11614.    } // endif
  11615.  
  11616.    // Now we make BitmapFile point to the filename only
  11617.    // We use pszBmp instead of BitmapFileName because  BitmapFileName
  11618.    // will be used after and have its content changed
  11619.    // --
  11620.    if ( BitmapFile = strrchr( pszBmp, '\\' ) ) {
  11621.       BitmapFile++;
  11622.    } else {
  11623.       BitmapFile = pszBmp;
  11624.    }
  11625.  
  11626.  
  11627.    // Try loading the bitmap from the current path with the given prefixing path
  11628.    // --
  11629.    if ( ! DosSearchPath( 0, DirPath, BitmapFile, BitmapFileName, MAXPATHL) ) {
  11630.       strcpy( pszPathName, DirPath );
  11631.       return 0;
  11632.    } // endif
  11633.  
  11634.    // Try loading the bitmap file from the exe directory
  11635.    // --
  11636.    {
  11637.       PSZ ExePath = UCMenuGetExePath();
  11638.       if ( ! DosSearchPath( 0, ExePath, BitmapFile, BitmapFileName, MAXPATHL) ) {
  11639.          strcpy( pszPathName, ExePath );
  11640.          MyFree( ExePath );
  11641.          return 0;
  11642.       } // endif
  11643.       MyFree( ExePath );
  11644.    }
  11645.  
  11646.    // If search Paths were specified search them
  11647.    // --
  11648.    if ( UCMData->szBitmapSearchPath[0] ) {
  11649.       strcpy( szBitmapSearchPath, UCMData->szBitmapSearchPath );
  11650.       FirstToken = 1;
  11651.       while( Path = strtok( FirstToken?szBitmapSearchPath:0, " " ) ) {
  11652.          if ( ! DosSearchPath( 2, Path, BitmapFile, BitmapFileName, MAXPATHL ) ) {
  11653.             Path = strrchr( BitmapFileName, '\\' );
  11654.             Path[0] = '\0';
  11655.             strcpy( pszPathName, BitmapFileName );
  11656.             return 0;
  11657.          } // endif
  11658.          FirstToken = 0;
  11659.       } // endwhile
  11660.    } // endif
  11661.  
  11662.    pszPathName[0] = '\0';
  11663.    return 1;
  11664. }
  11665.  
  11666. //----------------------------------------------------------------------------
  11667. // UCMenuGetBitmapFullName : not for the user's doc
  11668. //----------------------------------------------------------------------------
  11669. // :pfunction res=&IDF_BMPFULLNAME. name='UCMenuGetBitmapFullName' text='Finds the full access name of the given bitmap file'.
  11670. // This functions looks for the given file or the default one in  all the suitable directories and returns its full access name
  11671. // :syntax name='UCMenuGetBitmapFullName' params='UCMData, pszBmp, pszPathName' return='success'.
  11672. // :fparams.
  11673. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11674. // Pointer to the UCMData structure
  11675. // :fparam name='pszBmp' type='PSZ' io='input'.
  11676. // String of the searched filename, which can also include a path and a drive
  11677. // :fparam name='pszFullName' type='MPARAM' io='output' .
  11678. // Full name including the path found or "", must already be allocated to MAXPATHL characters
  11679. // :freturns.
  11680. // :fparam name='success' type='USHORT' io='return'.
  11681. // O if successful
  11682. // :efparams.
  11683. // :remarks.
  11684. // We look for the file (including any given path ) in the current directory, then we keep only the filename
  11685. // and look for it in the dir of the exe file, and in the path of the UCMData->pszBitmapSearchPath
  11686. // environment variables.
  11687. // :related.
  11688. // :epfunction.
  11689. //----------------------------------------------------------------------------
  11690. USHORT _Optlink UCMenuGetBitmapFullName( PUCMDATA UCMData, PSZ pszBmp, PSZ pszFullName )
  11691. {
  11692.    USHORT rc;
  11693.    PSZ    BitmapFile;
  11694.  
  11695.    rc = UCMenuGetBitmapPath( UCMData, pszBmp, pszFullName );
  11696.  
  11697.    // Strip any path prefixing the bitmap file name
  11698.    // --
  11699.    if ( ! ( BitmapFile = strrchr( pszBmp, '\\' ) ) ) {
  11700.       BitmapFile = pszBmp;
  11701.    } else {
  11702.       BitmapFile++;
  11703.    }
  11704.  
  11705.    if ( ! rc ) {
  11706.       ULONG ulLen = strlen( pszFullName );
  11707.       if ( pszFullName[ulLen-1] != '\\' ){
  11708.          strcat( pszFullName, "\\" );
  11709.       } // endif
  11710.       strcat( pszFullName, BitmapFile );
  11711.       return 0;
  11712.    } // endif
  11713.  
  11714. //... default bitmap may be a resource ID or file name, this
  11715. //... no longer works
  11716. //
  11717. // if ( *( UCMData->szDefaultBitmap ) ) {
  11718. //    rc = UCMenuGetBitmapPath( UCMData, UCMData->szDefaultBitmap, pszFullName );
  11719. //
  11720. //    // Strip any path prefixing the bitmap file name
  11721. //    // --
  11722. //    if ( ! ( BitmapFile = strrchr( UCMData->szDefaultBitmap, '\\' ) ) ) {
  11723. //       BitmapFile = UCMData->szDefaultBitmap;
  11724. //    } else {
  11725. //       BitmapFile++;
  11726. //    }
  11727. //
  11728. //    if ( ! rc ) {
  11729. //       ULONG ulLen = strlen( pszFullName );
  11730. //       if ( pszFullName[ulLen-1] != '\\' ){
  11731. //          strcat( pszFullName, "\\" );
  11732. //       } // endif
  11733. //       strcat( pszFullName, BitmapFile );
  11734. //       return 0;
  11735. //    } // endif
  11736. // } // endif pszDefaultBitmap
  11737.  
  11738.    pszFullName[0] = '\0';
  11739.    return 1;
  11740. }
  11741.  
  11742. //----------------------------------------------------------------------------
  11743. // GetMaxItemSize : not for the user's doc
  11744. //----------------------------------------------------------------------------
  11745. // :pfunction res=&IDF_MAXITSZ. name='GetMaxItemSize' text='Finds the size of the biggest item and updates UCMData'.
  11746. // This functions looks for the given file or the default one in  all the suitable directories and returns its full access name
  11747. // :syntax name='GetMaxItemSize' params='UCMData, hwndUCMenu, hwndMenu' return='-'.
  11748. // :fparams.
  11749. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11750. // Pointer to the UCMData structure
  11751. // :fparam name='hwndUCMenu' type='HWND' io='input'.
  11752. // UCMenu window handle
  11753. // :fparam name='hwndMenu' type='HWND' io='input' .
  11754. // Menu window handle
  11755. // :freturns.
  11756. // :fparam name='-' type='VOID' io='-'.
  11757. // :efparams.
  11758. // :remarks.
  11759. // :related.
  11760. // :epfunction.
  11761. //----------------------------------------------------------------------------
  11762. VOID _Optlink GetMaxItemSize(PUCMDATA UCMData, HWND hwndUCMenu, HWND hwndMenu)
  11763. {
  11764.    ULONG NumberOfItems = 0;
  11765.    ULONG Item;
  11766.    ULONG cx, cy;
  11767.    USHORT ItemID;
  11768.    MENUITEM mi;
  11769.    ULONG MaxHorizontalHeight, MaxVerticalWidth;
  11770.    ULONG SumItemWidths  = 0;
  11771.    ULONG SumItemHeights = 0;
  11772.  
  11773.    // Do not put anything but the actual new values in UCMData
  11774.    MaxVerticalWidth = MaxHorizontalHeight = 0;
  11775.  
  11776.    NumberOfItems = (ULONG)WinSendMsg(hwndMenu,
  11777.                                      MM_QUERYITEMCOUNT, 0L, 0L);
  11778.  
  11779.    if (NumberOfItems == 0) {
  11780.      cx = WinQuerySysValue(HWND_DESKTOP, SV_CYMENU); // Set empty toolbar to PM menu height
  11781.      UCMData->MaxHorizontalHeight = cx;
  11782.      UCMData->MaxVerticalWidth    = cx;
  11783.      UCMData->SumItemWidths  = cx;
  11784.      UCMData->SumItemHeights = cx;
  11785.      return;
  11786.    }
  11787.  
  11788.    for(Item=0; Item<NumberOfItems; Item++) {
  11789.       ItemID = (USHORT)WinSendMsg(hwndMenu,
  11790.                                   MM_ITEMIDFROMPOSITION,
  11791.                                   MPFROMSHORT(Item),
  11792.                                   (MPARAM)0);
  11793.       WinSendMsg(hwndMenu,
  11794.                  MM_QUERYITEM,
  11795.                  MPFROM2SHORT(ItemID,FALSE),
  11796.                  MPFROMP(&mi));
  11797.  
  11798.       if (mi.hItem) {
  11799.          UCMenuCalcUnscaledItemSize( (PUCMITEM)mi.hItem, UCMData->Style, hwndUCMenu, &cx, &cy );
  11800.          SumItemWidths  += cx;
  11801.          SumItemHeights += cy;
  11802.       } else {
  11803.          cx = cy = 0;
  11804.       } // endif
  11805.  
  11806.       if ( cx > MaxVerticalWidth) {
  11807.          MaxVerticalWidth = cx;
  11808.       } /* endif */
  11809.  
  11810.       if ( cy > MaxHorizontalHeight) {
  11811.          MaxHorizontalHeight = cy;
  11812.       } /* endif */
  11813.  
  11814.    }
  11815.  
  11816.    UCMData->MaxHorizontalHeight = MaxHorizontalHeight;
  11817.    UCMData->MaxVerticalWidth    = MaxVerticalWidth;
  11818.    UCMData->SumItemWidths  = SumItemWidths;
  11819.    UCMData->SumItemHeights = SumItemHeights;
  11820.  
  11821. }
  11822.  
  11823.  
  11824. //----------------------------------------------------------------------------
  11825. // TranslateAccel : not for the user's doc
  11826. //----------------------------------------------------------------------------
  11827. // :pfunction res=&IDF_TRNACC. name='TranslateAccel' text='Translates an accelerator'.
  11828. // This functions translates an accelerator
  11829. // :syntax name='TranslateAccel' params='UCMData, hwndMenu, Key, QMsg' return='success'.
  11830. // :fparams.
  11831. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11832. // Pointer to the UCMData structure
  11833. // :fparam name='hwndMenu' type='HWND' io='input'.
  11834. // Menu window handle
  11835. // :fparam name='Key' type='USHORT' io='input' .
  11836. // :fparam name='QMsg' type='PQMSG' io='output'.
  11837. // :freturns.
  11838. // :fparam name='success' type='BOOL' io='return'.
  11839. // 0 if failure.
  11840. // :efparams.
  11841. // :remarks.
  11842. // :related.
  11843. // :epfunction.
  11844. //----------------------------------------------------------------------------
  11845. BOOL _Optlink TranslateAccel(PUCMDATA UCMData, HWND HwndMenu, USHORT Key, PQMSG QMsg)
  11846. {
  11847.     ULONG NbOfItems = UCMData->AccelTable->cAccel;
  11848.     ULONG i;
  11849.     for(i=0; i<NbOfItems; i++) {
  11850.     //??? Accelerator keys don't work, and need to remove use of toupper()
  11851.     //ctype
  11852.     //   if(toupper(Key) == toupper(UCMData->AccelTable->aaccel[i].key)) {
  11853.     //      QMsg->hwnd = HwndMenu;
  11854.     //      QMsg->msg  = MM_SELECTITEM;
  11855.     //      QMsg->mp1  = (MPARAM)UCMData->AccelTable->aaccel[i].cmd;
  11856.     //      QMsg->mp2  = MPFROM2SHORT(0, 1);
  11857.     //      return 1;
  11858.     //   }
  11859.     }
  11860.     return 0;
  11861. }
  11862.  
  11863. //----------------------------------------------------------------------------
  11864. // AddAccelItem : not for the user's doc
  11865. //----------------------------------------------------------------------------
  11866. // :pfunction res=&IDF_ADDACC. name='AddAccelItem' text='Adds an accelerator item'.
  11867. // This functions adds an accelerator
  11868. // :syntax name='AddAccelItem' params='UCMData, Key, id' return='-'.
  11869. // :fparams.
  11870. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11871. // Pointer to the UCMData structure
  11872. // :fparam name='Key' type='USHORT' io='input' .
  11873. // :fparam name='id' type='ULONG' io='input'.
  11874. // :freturns.
  11875. // :fparam name='-' type='VOID' io='-'.
  11876. // :efparams.
  11877. // :remarks.
  11878. // :related.
  11879. // :epfunction.
  11880. //----------------------------------------------------------------------------
  11881. VOID  _Optlink AddAccelItem(PUCMDATA UCMData, USHORT Key, ULONG id)
  11882. {
  11883.    ULONG Item = UCMData->AccelTable->cAccel;
  11884.    ULONG i;
  11885.  
  11886.    for(i=0; i<Item; i++) {
  11887.       if(UCMData->AccelTable->aaccel[i].key == Key) {
  11888.          UCMData->AccelTable->aaccel[i].cmd = id;
  11889.          return;
  11890.       }
  11891.    }
  11892.  
  11893.    UCMData->AccelTable->aaccel[Item].key = Key;
  11894.    UCMData->AccelTable->aaccel[Item].fs = AF_CHAR+AF_ALT;
  11895.    UCMData->AccelTable->aaccel[Item].cmd = id;
  11896.    (UCMData->AccelTable->cAccel)++;
  11897. }
  11898.  
  11899. //----------------------------------------------------------------------------
  11900. // RemoveAccelItem : not for the user's doc
  11901. //----------------------------------------------------------------------------
  11902. // :pfunction res=&IDF_REMACC. name='RemoveAccelItem' text='Removes an accelerator item'.
  11903. // This functions removes an accelerator from the table in UCMData
  11904. // :syntax name='RemoveAccelItem' params='UCMData, Key' return='-'.
  11905. // :fparams.
  11906. // :fparam name='UCMData' type='PUCMDATA' io='input'.
  11907. // Pointer to the UCMData structure
  11908. // :fparam name='Key' type='USHORT' io='input' .
  11909. // :freturns.
  11910. // :fparam name='-' type='VOID' io='-'.
  11911. // :efparams.
  11912. // :remarks.
  11913. // :related.
  11914. // :epfunction.
  11915. //----------------------------------------------------------------------------
  11916. VOID _Optlink RemoveAccelItem(PUCMDATA UCMData, USHORT Key)
  11917. {
  11918.  
  11919.   ULONG i;
  11920.   for(i=0; i<UCMData->AccelTable->cAccel; i++) {
  11921.     if(Key == UCMData->AccelTable->aaccel[i].key) {
  11922.        break;
  11923.     }
  11924.   }
  11925.  
  11926.   if(i == UCMData->AccelTable->cAccel) {
  11927.      return;
  11928.   }
  11929.  
  11930.   if(i == (UCMData->AccelTable->cAccel-1)) {
  11931.      (UCMData->AccelTable->cAccel)--;
  11932.   }
  11933.  
  11934.   while(i < UCMData->AccelTable->cAccel) {
  11935.      memcpy(&(UCMData->AccelTable->aaccel[i]), &(UCMData->AccelTable->aaccel[i+1]), sizeof(ACCEL));
  11936.      i++;
  11937.   }
  11938.  
  11939.  (UCMData->AccelTable->cAccel)--;
  11940. }
  11941.  
  11942. #if defined(UCMUI)
  11943. //----------------------------------------------------------------------------
  11944. // BitmapFileDlgProc
  11945. //----------------------------------------------------------------------------
  11946. // :pfunction res=&IDF_BMPFILEDLGPROC. name='BitmapFileDlgProc' text='Subclassed file window procedure'.
  11947. // Checks that the given filename is a bitmap and loads it before dismissing the file dialog
  11948. // :syntax name='BitmapFileDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  11949. // :fparams.
  11950. // :fparam name='hwnd' type='HWND' io='input' .
  11951. // File dialog window handle
  11952. // :fparam name='msg' type='ULONG' io='input' .
  11953. // Message
  11954. // :fparam name='mp1' type='MPARAM' io='input'.
  11955. // First parameter
  11956. // :fparam name='mp2' type='MPARAM' io='input'.
  11957. // Second parameter
  11958. // :freturns.
  11959. // :fparam name='mresult' type='MRESULT' io='return'.
  11960. // Return code of a PM message.
  11961. // :efparams.
  11962. // :remarks.
  11963. // :epfunction.
  11964. //----------------------------------------------------------------------------
  11965. MRESULT EXPENTRY  BitmapFileDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  11966. {
  11967.    switch (msg) {
  11968.    case FDM_VALIDATE:
  11969.       {
  11970.           HBITMAP  hBmp;
  11971.           PFILEDLG FileDlg = (PFILEDLG) WinQueryWindowULong( hwnd, QWL_USER );
  11972.           PUCMDATA UCMData = (PUCMDATA) FileDlg->ulUser;
  11973.  
  11974.           if ( hBmp = UCMenuLoadBitmap( FileDlg->szFullFile ) ) {
  11975.              UCMData->hBmpTemp = hBmp;
  11976.              UCMData->bBmpTempFromFile = TRUE;
  11977.              return (MRESULT)TRUE;
  11978.           } else {
  11979.              WinMessageBox( HWND_DESKTOP, hwnd,
  11980.                             nlsgetmessage ( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_BADBMPFN, 0 ),
  11981.                             nlsgetmessage ( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_LOADBMP, 1 ),
  11982.                             0, MB_OK | MB_ERROR);
  11983.              WinSetFocus( HWND_DESKTOP, WinWindowFromID( hwnd, DID_FILENAME_ED ) );
  11984.              return (MRESULT)FALSE;
  11985.           } // endif
  11986.       }
  11987.    default:
  11988.      return WinDefFileDlgProc( hwnd, msg, mp1, mp2 );
  11989.  
  11990.    } // endswitch
  11991. }
  11992. #endif
  11993.  
  11994. #if defined(UCMUI)
  11995. //----------------------------------------------------------------------------
  11996. // UCMenuCreateBmpDlgProc
  11997. //----------------------------------------------------------------------------
  11998. // :pfunction res=&IDF_CREATEBMPDLGPROC. name='UCMEnuCreateBmpDlgProc' text='Bitmap creation dialog procedure'.
  11999. // Let the user enter a file name and start iconedit to create this bitmap.
  12000. // :syntax name='UCMenuCreateBmpDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  12001. // :fparams.
  12002. // :fparam name='hwnd' type='HWND' io='input' .
  12003. // File dialog window handle
  12004. // :fparam name='msg' type='ULONG' io='input' .
  12005. // Message
  12006. // :fparam name='mp1' type='MPARAM' io='input'.
  12007. // First parameter
  12008. // :fparam name='mp2' type='MPARAM' io='input'.
  12009. // Second parameter
  12010. // :freturns.
  12011. // :fparam name='mresult' type='MRESULT' io='return'.
  12012. // Return code of a PM message.
  12013. // :efparams.
  12014. // :remarks.
  12015. // :epfunction.
  12016. MRESULT EXPENTRY  UCMenuCreateBmpDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  12017. {
  12018.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER );
  12019.    switch (msg) {
  12020.       case WM_INITDLG:
  12021.       {
  12022.         WinSetWindowULong( hwnd, QWL_USER, (ULONG)mp2 );
  12023.         WinSetDlgItemShort( hwnd, IDC_UCMBMPCX, ((PUCMDATA)mp2)->cx, FALSE );
  12024.         WinSetDlgItemShort( hwnd, IDC_UCMBMPCY, ((PUCMDATA)mp2)->cy, FALSE );
  12025.       }
  12026.       break;
  12027.       case WM_COMMAND:
  12028.       {
  12029.          switch (SHORT1FROMMP(mp1)) {
  12030.             case IDB_UCMBMPOK:
  12031.             {
  12032.                UCHAR pszText[MAXPATHL];
  12033.                PSZ pszFullName = MyMalloc( MAXPATHL ); // Will be freed by UCMenuEditBmpFile
  12034.  
  12035.                if ( pszFullName ) {
  12036.                   SHORT cx, cy;
  12037.                   *pszText = '\0';
  12038.                   *pszFullName = '\0';
  12039.                   WinQueryDlgItemText( hwnd, IDC_UCMBMPNAME, (LONG)MAXPATHL, pszText );
  12040.                   WinQueryDlgItemShort( hwnd, IDC_UCMBMPCX, &cx, FALSE );
  12041.                   WinQueryDlgItemShort( hwnd, IDC_UCMBMPCY, &cy, FALSE );
  12042.                   UCMenuGetBitmapFullName( UCMData, pszText, pszFullName );
  12043.                   // We do that just to check whether the file already exists or not
  12044.                   if ( *pszFullName!='\0' ){
  12045.                      if ( WinMessageBox( HWND_DESKTOP, hwnd,
  12046.                                          nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_OVERWRITE, 0 ),
  12047.                                          nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_OVERWRITETITLE, 1 ),
  12048.                                          0, MB_YESNO ) != MBID_YES ){
  12049.                         MyFree( pszFullName );
  12050.                         return (MRESULT)TRUE;
  12051.                      } // endif
  12052.                   } // endif
  12053.                   UCMenuCreateBmpFile( pszText, cx, cy );
  12054.                   UCMenuGetBitmapFullName( UCMData, pszText, pszFullName );
  12055.                   UCMenuEditBmpFile( UCMData->hwndPage1, pszFullName );
  12056.                } // endif
  12057.             }
  12058.             // Fall through
  12059.             case IDB_UCMBMPCANCEL:
  12060.                WinDismissDlg( hwnd, TRUE );
  12061.                break;
  12062.             default:
  12063.                return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12064.          }
  12065.       }  break;
  12066.  
  12067.       default:
  12068.          return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12069.  
  12070.    } // endswitch
  12071.  
  12072.    return (MRESULT) FALSE;
  12073. }
  12074. #endif
  12075.  
  12076. #if defined(UCMUI)
  12077. //----------------------------------------------------------------------------
  12078. // ResBmpDlgProc
  12079. //----------------------------------------------------------------------------
  12080. // :pfunction res=&IDF_RESBMPDLGPROC. name='ResBmpDlgProc' text='Resource bitmap selection dialog procedure'.
  12081. // Let the user pick a bitmap among those available in the resource.
  12082. // :syntax name='ResBmpDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  12083. // :fparams.
  12084. // :fparam name='hwnd' type='HWND' io='input' .
  12085. // Dialog window handle
  12086. // :fparam name='msg' type='ULONG' io='input' .
  12087. // Message
  12088. // :fparam name='mp1' type='MPARAM' io='input'.
  12089. // First parameter
  12090. // :fparam name='mp2' type='MPARAM' io='input'.
  12091. // Second parameter
  12092. // :freturns.
  12093. // :fparam name='mresult' type='MRESULT' io='return'.
  12094. // Return code of a PM message.
  12095. // :efparams.
  12096. // :remarks.
  12097. // :epfunction.
  12098. MRESULT EXPENTRY  ResBmpDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  12099. {
  12100.    PUCMDATA UCMData = WinQueryWindowPtr( hwnd, 0 );
  12101.    switch (msg) {
  12102.       case WM_INITDLG:
  12103.       {
  12104.          UCMINFO  UCMInfo;
  12105.          HWND     hwndUCM;
  12106.          HWND     hOwner;
  12107.          PULONG   pId     = 0;
  12108.          ULONG    ulNbId  = 0;
  12109.  
  12110.          UCMData = (PUCMDATA)mp2;
  12111.          WinSetWindowPtr( hwnd, 0, UCMData );
  12112.  
  12113.          hwndUCM = WinQueryWindow( UCMData->hwndMenu, QW_OWNER );
  12114.          hOwner  = WinQueryWindow( hwndUCM, QW_OWNER );
  12115.  
  12116.          ulNbId = (ULONG)WinSendMsg( hOwner,
  12117.                               WM_CONTROL,
  12118.                               MPFROM2SHORT( WinQueryWindowUShort( hwndUCM, QWS_ID ), UCN_QRYRESBMP  ),
  12119.                               MPFROMP( &pId )  );
  12120.          if ( ulNbId && pId ){
  12121.             HWND     hwndUCM, hwndMenu;
  12122.             memset( &UCMInfo, 0, sizeof(UCMINFO) );
  12123.             UCMInfo.cb       = sizeof( UCMINFO );
  12124.             UCMInfo.hModule  = UCMData->hModBmp;
  12125.             UCMInfo.Style    = UCS_FRAMED | UCS_NOTEXT | UCS_NO_DM | UCS_NO_CM;
  12126.             if ( UCMData->Style & UCS_CHNGBMPBG ) {
  12127.                UCMInfo.Style |= UCS_CHNGBMPBG;
  12128.             } // endif
  12129.             if ( UCMData->Style & UCS_FORCESIZE ) {
  12130.                UCMInfo.Style |= UCS_FORCESIZE;
  12131.                UCMInfo.cx = UCMData->cx;
  12132.                UCMInfo.cy = UCMData->cy;
  12133.             } // endif
  12134.             UCMInfo.BgBmp       = UCMData->BgBmp;
  12135.             UCMInfo.BgColor     = UCMData->BgColor;
  12136.             UCMInfo.ItemBgColor = UCMData->ItemBgColor;
  12137.  
  12138.             hwndMenu = WinCreateWindow( HWND_OBJECT,
  12139.                                         WC_MENU,
  12140.                                         "",
  12141.                                         MS_ACTIONBAR,
  12142.                                         0,
  12143.                                         0,
  12144.                                         0,
  12145.                                         0,
  12146.                                         HWND_OBJECT,
  12147.                                         HWND_BOTTOM,
  12148.                                         7, // magic number ...
  12149.                                         0,
  12150.                                         0 );
  12151.             hwndUCM = UCMenuCreateFromHMenu(
  12152.                                           WinQueryAnchorBlock( hwnd ),
  12153.                                           hwnd,
  12154.                                           hwnd,
  12155.                                           CMS_HORZ,
  12156.                                           0,
  12157.                                           0,
  12158.                                           0,
  12159.                                           0,
  12160.                                           HWND_TOP,
  12161.                                           7,          // magic number ...
  12162.                                           hwndMenu,
  12163.                                           (PVOID)&UCMInfo );
  12164.  
  12165.             {
  12166.                PVOID pArgs;
  12167.  
  12168.                pArgs = MyMalloc( sizeof( HWND ) + sizeof( PULONG ) + sizeof( ULONG ) + sizeof( HWND ) );
  12169.  
  12170.                if ( pArgs ){
  12171.                   *( (HWND*)pArgs ) = hwnd;
  12172.                   *( (PULONG*)( (PBYTE)pArgs + sizeof( HWND ) ) ) = pId;
  12173.                   *( (PULONG)( (PBYTE)pArgs + sizeof( HWND ) + sizeof( PULONG ) ) ) = ulNbId;
  12174.                   *( (PHWND)( (PBYTE)pArgs + sizeof( HWND ) + sizeof( PULONG ) + sizeof( ULONG ) ) ) = hwndMenu;
  12175.  
  12176.                   WinSetDlgItemText( hwnd, IDC_RESBMPTEXT, nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_BMPLOADING, 0 ) );
  12177.  
  12178.                   DosCreateThread( &( UCMData->tid ), (PFNTHREAD)UCMenuLoadResBmp, (ULONG)pArgs, 0, 8192 );
  12179.                } // endif
  12180.             }
  12181.          } else {
  12182.             WinSetDlgItemText( hwnd, IDC_RESBMPTEXT, nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_NOBMPRES, 0 ) );
  12183.          } // endif
  12184.       }
  12185.       break;
  12186.       case WM_CONTROL:
  12187.       {
  12188.          switch ( SHORT1FROMMP( mp1 ) ){
  12189.          case 7: // ID of the ucmenu ...
  12190.             switch ( SHORT2FROMMP( mp1 ) ){
  12191.             case UCN_ITEMSELECTED:
  12192.                {
  12193.                   PUCMITEM pucmi = (PUCMITEM)mp2;
  12194.                   if ( pucmi ) {
  12195.                      sscanf( pucmi->pszBmp, "%i", &( UCMData->ulBmpTempId ) );
  12196.                   } else {
  12197.                      UCMData->ulBmpTempId = 0;
  12198.                   } // endif
  12199.                   WinDismissDlg( hwnd, (USHORT)1 );
  12200.                   return (MRESULT)TRUE;
  12201.                }
  12202.                break;
  12203.             default :
  12204.                return (MRESULT)0;
  12205.  
  12206.             } // endswitch
  12207.             break;
  12208.          default:
  12209.             return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12210.  
  12211.          } // endswitch
  12212.       }
  12213.       break;
  12214.       case WM_CLOSE:
  12215.          if ( DosWaitThread( &( UCMData->tid ), DCWW_NOWAIT ) != ERROR_THREAD_NOT_TERMINATED ){
  12216.             // Don't close unless the threaded loading ended, else trouble!
  12217.             return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12218.          } /* endif */;
  12219.          break;
  12220.       case WM_COMMAND:
  12221.       {
  12222.  
  12223.          switch ( SHORT1FROMMP( mp1 ) ) {
  12224.             case DID_CANCEL:
  12225.             case IDB_RESBMPCANCEL:
  12226.                if ( DosWaitThread( &( UCMData->tid ), DCWW_NOWAIT ) != ERROR_THREAD_NOT_TERMINATED ){
  12227.                   // Don't dismiss unless the threaded loading ended, else trouble!
  12228.                   WinDismissDlg( hwnd, 0 );
  12229.                } /* endif */;
  12230.                break;
  12231.             default:
  12232.                return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12233.          }
  12234.       }  break;
  12235.  
  12236.       default:
  12237.          return WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12238.          break;
  12239.    } // endswitch
  12240.  
  12241.    return (MRESULT) FALSE;
  12242. }
  12243. #endif
  12244.  
  12245.  
  12246. #if defined(UCMUI)
  12247. //----------------------------------------------------------------------------
  12248. // UCMDlgProc
  12249. //----------------------------------------------------------------------------
  12250. // :pfunction res=&IDF_UCMDLGPROC. name='UCMDlgProc' text='Buffet toolbar selection dialog procedure'.
  12251. // Let the user pick items from the buffet toolbar
  12252. // :syntax name='ResBmpDlgProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  12253. // :fparams.
  12254. // :fparam name='hwnd' type='HWND' io='input' .
  12255. // Dialog window handle
  12256. // :fparam name='msg' type='ULONG' io='input' .
  12257. // Message
  12258. // :fparam name='mp1' type='MPARAM' io='input'.
  12259. // First parameter
  12260. // :fparam name='mp2' type='MPARAM' io='input'.
  12261. // Second parameter
  12262. // :freturns.
  12263. // :fparam name='mresult' type='MRESULT' io='return'.
  12264. // Return code of a PM message.
  12265. // :efparams.
  12266. // :remarks.
  12267. // :epfunction.
  12268. MRESULT EXPENTRY UCMDlgProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
  12269. {
  12270.    PUCMDLGINFO pUCMDlgInfo = (PUCMDLGINFO)WinQueryWindowULong( hwnd, QWL_USER );
  12271.  
  12272.    if ( !pUCMDlgInfo && ( msg != WM_INITDLG ) ) {
  12273.      return( WinDefDlgProc( hwnd, msg, mp1, mp2 ) );
  12274.    } /* endif */
  12275.  
  12276.    switch ( msg ) {
  12277.    case WM_INITDLG:
  12278.      {
  12279.        PVOID    pCurUCMTemplate;
  12280.        ULONG    ulBufLen;
  12281.        SWP      swpBuffetDesc, swpCurrentDesc, swpText, swp;
  12282.        HWND     hwndBuffet, hwndCurrent, hwndTmp;
  12283.        UCMINFO  UCMInfo;
  12284.        HAB      hab = WinQueryAnchorBlock( hwnd );
  12285.  
  12286.        pUCMDlgInfo = (PUCMDLGINFO)mp2;
  12287.        if ( !pUCMDlgInfo ) {
  12288.          return (MRESULT)FALSE;
  12289.        } /* endif */
  12290.  
  12291.        WinSetWindowULong( hwnd, QWL_USER, (ULONG)pUCMDlgInfo );
  12292.  
  12293.        // Query the desc positions
  12294.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENTDESC ), &swpCurrentDesc );
  12295.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFETDESC ),  &swpBuffetDesc  );
  12296.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_TEXT ),  &swpText  );
  12297.        WinQueryWindowPos( hwnd, &swp );
  12298.  
  12299.        // Query the current toolbar
  12300.        pCurUCMTemplate = UCMenuMakeTemplate( pUCMDlgInfo->hwndUCMenu, &ulBufLen );
  12301.  
  12302.        // Query Its UCMINFO structure
  12303.        memset( &UCMInfo, '\0', sizeof UCMInfo );
  12304.        WinSendMsg( pUCMDlgInfo->hwndUCMenu, UCMENU_QUERYUCMINFO, MPFROMP( & UCMInfo ), (MPARAM)0 );
  12305.  
  12306.        WinCheckButton( hwnd, IDD_UCMDLG_TEXT, ( UCMInfo.Style & UCS_NOTEXT )? FALSE : TRUE );
  12307.  
  12308.        UCMInfo.cb     =  sizeof( UCMINFO );
  12309.        UCMInfo.Style &= UCS_FORCESIZE             |
  12310.                         UCS_FRAMED                |
  12311.                         UCS_NOTEXT                |
  12312.                         UCS_SHRINK_BLEND          |
  12313.                         UCS_SHRINK_OR             |
  12314.                         UCS_CHNGBMPBG             |
  12315.                         UCS_NO_CM_SEPARATOR       |
  12316.                         UCS_NO_CM_MENU_STYLE      |
  12317.                         UCS_NO_CM_MENU_IMPORT     |
  12318.                         UCS_NO_CM_MENU_EXPORT     |
  12319.                         UCS_NO_CM_MENU_DEFAULT    |
  12320.                         UCS_NO_CM_ITEM_EDIT       |
  12321.                         UCS_NO_CM_ITEM_CREATE     |
  12322.                         UCS_NO_CM_ITEM_DELETE     |
  12323.                         UCS_NO_CM                 |
  12324.                         UCS_NODEFAULTACTION;
  12325.  
  12326.        // Create its copy
  12327.        hwndCurrent = UCMenuCreateFromTemplate(
  12328.                                  hab,
  12329.                                  hwnd,
  12330.                                  hwnd,
  12331.                                  CMS_HORZ,
  12332.                                  0,
  12333.                                  0,
  12334.                                  swp.cx - swpCurrentDesc.x -14,
  12335.                                  0,
  12336.                                  HWND_TOP,
  12337.                                  IDD_UCMDLG_CURRENT,  // ID of the ucmenu, could be different from the menu id
  12338.                                  pCurUCMTemplate,     // module of the menu resource
  12339.                                  (PVOID)&UCMInfo,
  12340.                                  &hwndTmp );
  12341.        if ( pCurUCMTemplate ) {
  12342.          MyFree( pCurUCMTemplate );
  12343.        } /* endif */
  12344.  
  12345.        // Create the buffet toolbar
  12346.        UCMInfo.Style &= UCS_FORCESIZE |
  12347.                         UCS_FRAMED |
  12348.                         UCS_NOTEXT |
  12349.                         UCS_SHRINK_BLEND |
  12350.                         UCS_SHRINK_OR |
  12351.                         UCS_CHNGBMPBG;
  12352.        UCMInfo.Style |=  UCS_NO_CM | UCS_NOITEMSMODIF;
  12353.        UCMInfo.Style &= ~UCS_NO_DM_C_TO_OTHER;
  12354.        if ( pUCMDlgInfo->bFromTemplate ){
  12355.           hwndBuffet = UCMenuCreateFromTemplate(
  12356.                                     hab,
  12357.                                     hwnd,
  12358.                                     hwnd,
  12359.                                     CMS_HORZ,
  12360.                                     0,
  12361.                                     0,
  12362.                                     swp.cx - swpBuffetDesc.x -14,
  12363.                                     0,
  12364.                                     HWND_TOP,
  12365.                                     IDD_UCMDLG_BUFFET,  // ID of the ucmenu, could be different from the menu id
  12366.                                     pUCMDlgInfo->pTemplate,
  12367.                                     (PVOID)&UCMInfo,
  12368.                                     &hwndTmp );
  12369.        } else {
  12370.           hwndBuffet = UCMenuCreateFromResource(
  12371.                                     hab,
  12372.                                     hwnd,
  12373.                                     hwnd,
  12374.                                     CMS_HORZ,
  12375.                                     0,
  12376.                                     0,
  12377.                                     swp.cx - swpBuffetDesc.x -14,
  12378.                                     0,
  12379.                                     HWND_TOP,
  12380.                                     IDD_UCMDLG_BUFFET,  // ID of the ucmenu, could be different from the menu id
  12381.                                     pUCMDlgInfo->hmodBuffetMenu,
  12382.                                     pUCMDlgInfo->ulBuffetMenuID,
  12383.                                     (PVOID)&UCMInfo,
  12384.                                     &hwndTmp );
  12385.        } // endif
  12386.  
  12387.        // Subclass the icon to destroy items dropped over it
  12388.        WinSetWindowULong( WinWindowFromID( hwnd, IDD_UCMDLG_SHREDDER ), QWL_USER, (ULONG)pUCMDlgInfo );
  12389.        pUCMDlgInfo->OldShredderWndProc = WinSubclassWindow( WinWindowFromID( hwnd, IDD_UCMDLG_SHREDDER ), ShredderWndProc );
  12390.  
  12391.        WinSendMsg( hwnd, WM_SIZE, (MPARAM)0, (MPARAM)0 );
  12392.  
  12393.        // Ask for the list of actions and descriptions
  12394.        WinSendMsg( WinQueryWindow( pUCMDlgInfo->hwndUCMenu, QW_OWNER ),
  12395.                    WM_CONTROL,
  12396.                    MPFROM2SHORT( WinQueryWindowUShort( pUCMDlgInfo->hwndUCMenu, QWS_ID ), UCN_QRYACTIONLIST ),
  12397.                    MPFROMP( hwnd ) );
  12398.  
  12399.  
  12400.        // Cleanup
  12401.        if ( UCMInfo.pszBitmapSearchPath ) {
  12402.          MyFree( UCMInfo.pszBitmapSearchPath );
  12403.        } /* endif */
  12404.        if ( UCMInfo.pszDefaultBitmap ) {
  12405.          MyFree( UCMInfo.pszDefaultBitmap );
  12406.        } /* endif */
  12407.        if ( UCMInfo.pszFontNameSize ) {
  12408.          MyFree( UCMInfo.pszFontNameSize );
  12409.        } /* endif */
  12410.  
  12411.        return (MRESULT)FALSE;
  12412.      }
  12413.  
  12414.    case UCMENU_INSERTACTION:
  12415.       {
  12416.          WinSendDlgItemMsg( hwnd,
  12417.                             IDD_UCMDLG_ACTIONS,
  12418.                             LM_INSERTITEM,
  12419.                             (MPARAM)LIT_END,
  12420.                             mp1 );
  12421.          WinSendDlgItemMsg( hwnd,
  12422.                             IDD_UCMDLG_DESCR,
  12423.                             LM_INSERTITEM,
  12424.                             (MPARAM)LIT_END,
  12425.                             mp2 );
  12426.          return (MRESULT)0;
  12427.       }
  12428.  
  12429.    case WM_CONTROL:
  12430.      if ( ( SHORT1FROMMP( mp1 ) == IDD_UCMDLG_CURRENT || SHORT1FROMMP( mp1 ) == IDD_UCMDLG_BUFFET ) &&
  12431.           ( SHORT2FROMMP( mp1 ) == UCN_ITEMSELECTED ) ){
  12432.         PUCMITEM pucmi = (PUCMITEM)mp2;
  12433.         SHORT  sIndex;
  12434.         PSZ    pszTxt;
  12435.         CHAR   pszDesc[MAXDESCLEN];
  12436.  
  12437.         if ( pucmi && pucmi->pszAction ){
  12438.            pszTxt = pucmi->pszAction;
  12439.         } else {
  12440.            return (MRESULT)FALSE;
  12441.         } /* endif */
  12442.         sIndex = (USHORT)WinSendDlgItemMsg( hwnd,
  12443.                                             IDD_UCMDLG_ACTIONS,
  12444.                                             LM_SEARCHSTRING,
  12445.                                             MPFROM2SHORT( LSS_CASESENSITIVE, LIT_FIRST ),
  12446.                                             MPFROMP( pszTxt ) );
  12447.         if ( sIndex != LIT_NONE && sIndex != LIT_ERROR ){
  12448.            WinSendDlgItemMsg( hwnd,
  12449.                               IDD_UCMDLG_DESCR,
  12450.                               LM_QUERYITEMTEXT,
  12451.                               MPFROM2SHORT( sIndex, MAXDESCLEN ),
  12452.                               MPFROMP( pszDesc ) );
  12453.            WinMessageBox( HWND_DESKTOP, hwnd,
  12454.                           pszDesc,
  12455.                           nlsgetmessage( WinQueryAnchorBlock( hwnd ),
  12456.                                          pUCMDlgInfo->UCMData->hModUCM,
  12457.                                          NLS_ITEMDESCR, 0 ),
  12458.                           0, MB_CANCEL | MB_INFORMATION | MB_APPLMODAL | MB_MOVEABLE );
  12459.         } // endif
  12460.         return (MRESULT)FALSE;
  12461.      } /* endif */
  12462.      switch ( SHORT1FROMMP( mp1 ) ) {
  12463.      case IDD_UCMDLG_TEXT:
  12464.         switch ( SHORT2FROMMP( mp1 ) ){
  12465.         case BN_CLICKED:
  12466.           {
  12467.             ULONG  ulStyle1, ulStyle2, ulCx1, ulCy1, ulCx2, ulCy2;
  12468.             USHORT usText;
  12469.             WinSendMsg( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFET ),
  12470.                         UCMENU_QUERYSTYLE,
  12471.                         MPFROMP( &ulStyle1 ),
  12472.                         (MPARAM)0 );
  12473.             WinSendMsg( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ),
  12474.                         UCMENU_QUERYSTYLE,
  12475.                         MPFROMP( &ulStyle2 ),
  12476.                         (MPARAM)0 );
  12477.             WinSendMsg( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFET ),
  12478.                         UCMENU_QUERYFORCEDSIZE,
  12479.                         MPFROMP( &ulCx1 ),
  12480.                         MPFROMP( &ulCy1 ) );
  12481.             WinSendMsg( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ),
  12482.                         UCMENU_QUERYFORCEDSIZE,
  12483.                         MPFROMP( &ulCx2 ),
  12484.                         MPFROMP( &ulCy2 ) );
  12485.             usText = WinQueryButtonCheckstate( hwnd, IDD_UCMDLG_TEXT );
  12486.             if ( usText ) {
  12487.                ulStyle1 &= ~UCS_NOTEXT;
  12488.                ulStyle2 &= ~UCS_NOTEXT;
  12489.             } else {
  12490.                ulStyle1 |= UCS_NOTEXT;
  12491.                ulStyle2 |= UCS_NOTEXT;
  12492.             } /* endif */
  12493.             WinPostMsg( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFET ),
  12494.                         UCMENU_SETSTYLE,
  12495.                         (MPARAM)ulStyle1,
  12496.                         MPFROM2SHORT( (USHORT)ulCx1, (USHORT)ulCy1 ) );
  12497.             WinPostMsg( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ),
  12498.                         UCMENU_SETSTYLE,
  12499.                         (MPARAM)ulStyle2,
  12500.                         MPFROM2SHORT( (USHORT)ulCx2, (USHORT)ulCy2 ) );
  12501.             WinPostMsg( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFET ),
  12502.                         UCMENU_UPDATE,
  12503.                         (MPARAM)0,
  12504.                         (MPARAM)0 );
  12505.             WinPostMsg( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ),
  12506.                         UCMENU_UPDATE,
  12507.                         (MPARAM)0,
  12508.                         (MPARAM)0 );
  12509.  
  12510.           }
  12511.           break;
  12512.         default:
  12513.           break;
  12514.         } /* endswitch */
  12515.  
  12516.      case IDD_UCMDLG_CURRENT:
  12517.         switch ( SHORT2FROMMP( mp1 ) ){
  12518.         case UCN_SIZE:
  12519.            WinSendMsg( hwnd, WM_SIZE, (MPARAM)0, (MPARAM)0 );
  12520.            break;
  12521.         case UCN_QRYDEFTEMPLATEID:
  12522.         case UCN_QRYTEMPLATEMODULE:
  12523.         case UCN_QRYDEFTEMPLATE:
  12524.         case UCN_QRYACTIONLIST:
  12525.         case UCN_QRYRESBMP:
  12526.            mp1 = MPFROM2SHORT( WinQueryWindowUShort( pUCMDlgInfo->hwndUCMenu, QWS_ID ), SHORT2FROMMP( mp1 ) );
  12527.            return WinSendMsg( WinQueryWindow( pUCMDlgInfo->hwndUCMenu, QW_OWNER ),
  12528.                               msg, mp1, mp2 );
  12529.  
  12530.         default:
  12531.           break;
  12532.         } /* endswitch */
  12533.  
  12534.      default:
  12535.        break;
  12536.      } /* endswitch */
  12537.  
  12538.   case WM_COMMAND:
  12539.      switch ( (USHORT)mp1 ) {
  12540.      case IDD_UCMDLG_OK:
  12541.        { PVOID  pNewTemplate;
  12542.          ULONG  ulLen;
  12543.          pNewTemplate =
  12544.            UCMenuMakeTemplate( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ), &ulLen );
  12545.          UCMenuNew( pUCMDlgInfo->hwndUCMenu, pNewTemplate );
  12546.          MyFree( pNewTemplate );
  12547.          WinDismissDlg( hwnd, 1 );
  12548.  
  12549.          // process the text checkmark
  12550. #if 0
  12551.          WinSendMsg( pUCMDlgInfo->hwndUCMenu,
  12552.                      UCMENU_QUERYSTYLE,
  12553.                      MPFROMP( &ulStyle ),
  12554.                      (MPARAM)0 );
  12555.          WinSendMsg( pUCMDlgInfo->hwndUCMenu,
  12556.                      UCMENU_QUERYFORCEDSIZE,
  12557.                      MPFROMP( &ulCx ),
  12558.                      MPFROMP( &ulCy ) );
  12559.          usText = WinQueryButtonCheckstate( hwnd, IDD_UCMDLG_TEXT );
  12560.          if ( usText ) {
  12561.             elQtyle &= ~UCS_NOTEXT;
  12562.          } else {
  12563.             ulStyle |= UCS_NOTEXT;
  12564.          } /* endif */
  12565.          WinPostMsg( pUCMDlgInfo->hwndUCMenu,
  12566.                     UCMENU_SETSTYLE,
  12567.                      (MPARAM) ulStyle,
  12568.                      MPFROM2SHORT( (USHORT)ulCx, (USHORT)ulCy ) );
  12569.          WinPostMsg( pUCMDlgInfo->hwndUCMenu,
  12570.                      UCMENU_UPDATE,
  12571.                      (MPARAM)0,
  12572.                      (MPARAM)0 );
  12573. #endif
  12574.        }
  12575.        break;
  12576.      case DID_CANCEL:
  12577.      case IDD_UCMDLG_CANCEL:
  12578.        WinDismissDlg( hwnd, 0 );
  12579.        break;
  12580.      case IDD_UCMDLG_DEFAULT:
  12581.        UCMenuLoadDefault( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT ) );
  12582.        break;
  12583.     case IDD_UCMDLG_HELP:
  12584.        UCMenuDisplayHelp( pUCMDlgInfo->UCMData,
  12585.                           (USHORT)PANEL_BUFFET,
  12586.                           (USHORT)UCN_HLP_BUFFET );
  12587.        break;
  12588.      default:
  12589.        break;
  12590.      } /* endswitch */
  12591.      break;
  12592.   case WM_SIZE:
  12593.      {
  12594.        SWP   swpCurrentDesc, swpBuffetDesc, swpText, swp;
  12595.        HWND  hwndCurrent, hwndBuffet;
  12596.        ULONG ulCxBuf, ulCyBuf, ulCxCur, ulCyCur;
  12597.  
  12598.        hwndCurrent = WinWindowFromID( hwnd, IDD_UCMDLG_CURRENT );
  12599.        hwndBuffet  = WinWindowFromID( hwnd, IDD_UCMDLG_BUFFET );
  12600.  
  12601.        // Query the desc positions
  12602.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENTDESC ), &swpCurrentDesc );
  12603.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFETDESC ),  &swpBuffetDesc  );
  12604.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_TEXT ),  &swpText  );
  12605.        WinQueryWindowPos( hwnd, &swp );
  12606.  
  12607.        // query its height, set its position and show it
  12608.        WinSendMsg( hwndCurrent, UCMENU_QUERYSIZE, MPFROMP(&ulCxCur), MPFROMP(&ulCyCur) );
  12609.        WinSetWindowPos( hwndCurrent,
  12610.                         HWND_TOP,
  12611.                         swpCurrentDesc.x + 6,
  12612.                         swpText.y + swpText.cy + 10,
  12613.                         0,
  12614.                         0,
  12615.                         SWP_MOVE | SWP_SHOW );
  12616.        WinSetWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENTDESC ),
  12617.                         HWND_TOP,
  12618.                         swpCurrentDesc.x,
  12619.                         swpText.y + swpText.cy + ulCyCur + 15,
  12620.                         0,
  12621.                         0,
  12622.                         SWP_MOVE | SWP_SHOW );
  12623.        WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_CURRENTDESC ), &swpCurrentDesc );
  12624.  
  12625.        // query its height, set its position and show it
  12626.        WinSendMsg( hwndBuffet, UCMENU_QUERYSIZE, MPFROMP(&ulCxBuf), MPFROMP(&ulCyBuf) );
  12627.        WinSetWindowPos( hwndBuffet,
  12628.                         HWND_TOP,
  12629.                         swpBuffetDesc.x + 6,
  12630.                         swpCurrentDesc.y + swpCurrentDesc.cy + 10,
  12631.                         0,
  12632.                         0,
  12633.                         SWP_MOVE | SWP_SHOW );
  12634.        WinSetWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_BUFFETDESC ),
  12635.                         HWND_TOP,
  12636.                         swpBuffetDesc.x,
  12637.                         swpCurrentDesc.y + swpCurrentDesc.cy + ulCyBuf + 15,
  12638.                         0,
  12639.                         0,
  12640.                         SWP_MOVE | SWP_SHOW );
  12641.        WinSetWindowPos( hwnd,
  12642.                         HWND_TOP,
  12643.                         0,
  12644.                         0,
  12645.                         swp.cx,
  12646.                         swpCurrentDesc.y + swpCurrentDesc.cy + ulCyBuf + swpBuffetDesc.cy + 20
  12647.                          + WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR ) + WinQuerySysValue( HWND_DESKTOP, SV_CYDLGFRAME ),
  12648.                         SWP_SIZE | SWP_SHOW );
  12649.         return (MRESULT)0;
  12650.      }
  12651.      break;
  12652. //case WM_PAINT:
  12653. //   {
  12654. //      RECTL rcl;
  12655. //      SWP   swp;
  12656. //      HPS   hps;
  12657. //
  12658. //      WinDefDlgProc( hwnd, msg, mp1, mp2 );
  12659. //
  12660. //      WinQueryWindowPos( WinWindowFromID( hwnd, IDD_UCMDLG_SHREDDER ), &swp );
  12661. //      rcl.xLeft   = swp.x - 10;
  12662. //      rcl.xRight  = swp.x + swp.cx + 10;
  12663. //      rcl.yBottom = swp.y - 10;
  12664. //      rcl.yTop    = swp.y + swp.cy + 10;
  12665. //      hps = WinGetPS( hwnd );
  12666. //      UCMenu3DFrame( hps, &rcl, TRUE );
  12667. //      WinDrawBorder( hps, &rcl, 1, 1, CLR_BLACK, 0, DB_PATCOPY );
  12668. //      WinReleasePS( hps );
  12669. //   }
  12670. //   break;
  12671.   default:
  12672.       return( WinDefDlgProc( hwnd, msg, mp1, mp2 ) );
  12673.       break;
  12674.    } /* endswitch */
  12675.    return (MRESULT)FALSE;
  12676.  
  12677. }
  12678. #endif
  12679.  
  12680.  
  12681. #if defined(UCMUI)
  12682. //----------------------------------------------------------------------------
  12683. // ShredderWndProc
  12684. //----------------------------------------------------------------------------
  12685. // :pfunction res=&IDF_SHRDDRWNDPROC. name='ShredderWndProc' text='Subclassed wnd proc for the shredder icon'.
  12686. // This wndproc processes the drop of ucmenu items over the buffet dialog shredder.
  12687. // :syntax name='ShredderWndProc' params='hwnd, msg, mp1, mp2' return='mresult' .
  12688. // :fparams.
  12689. // :fparam name='hwnd' type='HWND' io='input' .
  12690. // Window handle
  12691. // :fparam name='msg' type='ULONG' io='input' .
  12692. // Message
  12693. // :fparam name='mp1' type='MPARAM' io='input'.
  12694. // First parameter
  12695. // :fparam name='mp2' type='MPARAM' io='input'.
  12696. // Second parameter
  12697. // :freturns.
  12698. // :fparam name='mresult' type='MRESULT' io='return'.
  12699. // Return code of a PM message.
  12700. // :efparams.
  12701. // :remarks.
  12702. // :epfunction.
  12703. MRESULT EXPENTRY ShredderWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
  12704. {
  12705.    PUCMDLGINFO pUCMDlgInfo = (PUCMDLGINFO)WinQueryWindowULong( hwnd, QWL_USER );
  12706.  
  12707.    if ( !pUCMDlgInfo ) {
  12708.      return( WinDefWindowProc( hwnd, msg, mp1, mp2 ) );
  12709.    } /* endif */
  12710.  
  12711.    switch ( msg ){
  12712.    case DM_DRAGLEAVE:
  12713.       {
  12714.          RECTL rcl;
  12715.          HPS hps = DrgGetPS( hwnd );
  12716.          WinQueryWindowRect( hwnd, &rcl );
  12717. //       rcl.xLeft   -=  5;
  12718. //       rcl.xRight  +=  5;
  12719. //       rcl.yBottom -=  5;
  12720. //       rcl.yTop    +=  5;
  12721.          WinDrawBorder( hps, &rcl, 1, 1, CLR_PALEGRAY, 0, DB_PATCOPY);
  12722.          DrgReleasePS( hps );
  12723.       }
  12724.       break;
  12725.    case DM_DRAGOVER:
  12726.       {
  12727.        PDRAGINFO  pDraginfo = (PDRAGINFO)mp1;
  12728.        USHORT     usOperation, usIndicator;
  12729.        PDRAGITEM  pditem;
  12730.        RECTL rcl;
  12731.        HPS hps = DrgGetPS( hwnd );
  12732.  
  12733.        WinQueryWindowRect( hwnd, &rcl );
  12734. //     rcl.xLeft   -=  5;
  12735. //     rcl.xRight  +=  5;
  12736. //     rcl.yBottom -=  5;
  12737. //     rcl.yTop    +=  5;
  12738.        WinDrawBorder( hps, &rcl, 1, 1, CLR_BLACK, 0, DB_PATCOPY);
  12739.        DrgReleasePS( hps );
  12740.  
  12741.        /* ---------------------------------------------------------------------- */
  12742.        /* Get access to the DRAGINFO structure.                                  */
  12743.        /* ---------------------------------------------------------------------- */
  12744.        DrgAccessDraginfo( pDraginfo );
  12745.        pditem = DrgQueryDragitemPtr( pDraginfo, 0 );
  12746.  
  12747.        if ( WinQueryWindowUShort( WinQueryWindow( pDraginfo->hwndSource, QW_OWNER ), QWS_ID )
  12748.             != IDD_UCMDLG_CURRENT ) {
  12749.           usIndicator = DOR_NEVERDROP;
  12750.           DrgFreeDraginfo (pDraginfo);
  12751.           return (MRFROM2SHORT(usIndicator, usOperation));
  12752.        } /* endif */
  12753.  
  12754.        /* ---------------------------------------------------------------------- */
  12755.        /* Determine if a drop can be accepted                                    */
  12756.        /* ---------------------------------------------------------------------- */
  12757.        usIndicator = DOR_DROP;
  12758.        usOperation = pDraginfo->usOperation;
  12759.        switch (pDraginfo->usOperation) {
  12760.          case DO_COPY:
  12761.            usIndicator = DOR_NODROPOP;
  12762.            break;
  12763.          case DO_MOVE:
  12764.            usOperation = DO_MOVE;
  12765.            break;
  12766.          case DO_DEFAULT:
  12767.            usOperation = DO_MOVE;
  12768.            break;
  12769.          case DO_UNKNOWN:
  12770.             usIndicator = DOR_NODROPOP;
  12771.             break;
  12772.         default:
  12773.            usIndicator = DOR_NODROP;
  12774.            usOperation = 0;
  12775.        } // endswitch
  12776.  
  12777.        if ( !DrgVerifyRMF( pditem, "DRM_UCMITEM",  "DRF_UNKNOWN" ) ){
  12778.           usIndicator = DOR_NEVERDROP;
  12779.        } // endif
  12780.  
  12781.  
  12782.        DrgFreeDraginfo( pDraginfo );
  12783.  
  12784.        return MRFROM2SHORT( usIndicator, usOperation );
  12785.       }
  12786.       break;
  12787.    case DM_DROP:
  12788.       {
  12789.          PDRAGINFO pDraginfo = (PDRAGINFO)mp1;
  12790.          PDRAGITEM pditem;
  12791.          RECTL rcl;
  12792.          HPS hps = DrgGetPS( hwnd );
  12793.          WinQueryWindowRect( hwnd, &rcl );
  12794. //       rcl.xLeft   -=  5;
  12795. //       rcl.xRight  +=  5;
  12796. //       rcl.yBottom -=  5;
  12797. //       rcl.yTop    +=  5;
  12798.          WinDrawBorder( hps, &rcl, 1, 1, CLR_PALEGRAY, 0, DB_PATCOPY);
  12799.          DrgReleasePS( hps );
  12800.  
  12801.          DrgAccessDraginfo( pDraginfo );
  12802.  
  12803.          pditem = DrgQueryDragitemPtr( pDraginfo, 0 );
  12804.  
  12805.          if ( pditem ){
  12806.               switch ( pDraginfo->usOperation ){
  12807.                 case DO_MOVE:
  12808.                    WinSendMsg( WinQueryWindow( pDraginfo->hwndSource, QW_OWNER ),
  12809.                                MM_DELETEITEM,
  12810.                                MPFROM2SHORT( (USHORT)(pditem->ulItemID), TRUE ),
  12811.                                (MPARAM)0 );
  12812.                    break;
  12813.                 default:
  12814.                   //-- invalid operation
  12815.                   break;
  12816.               } // endswitch
  12817.          } // endif  pditem
  12818.  
  12819.          // ----------------------------------------------------------------------
  12820.          // -- free the resource:
  12821.          // ----------------------------------------------------------------------
  12822.          DrgDeleteDraginfoStrHandles( pDraginfo );
  12823.          DrgFreeDraginfo( pDraginfo );
  12824.       }
  12825.       break;
  12826.    default:
  12827.       return pUCMDlgInfo->OldShredderWndProc( hwnd, msg, mp1, mp2 );
  12828.       break;
  12829.    } // endif
  12830.    return (MRESULT)0;
  12831. }
  12832. #endif
  12833.  
  12834. //----------------------------------------------------------------------------
  12835. // UCMenuResourceBuffetDlg
  12836. //----------------------------------------------------------------------------
  12837. // :function res=&IDF_RESBUFFETDLG. name='UCMenuResourceBuffetDlg' text='Toolbar customization dialog'.
  12838. // This dialog let the user pick items from a buffet toolbar coming from a resource..
  12839. // :syntax name='UCMenuResourceBuffetDlg' params='hParent, hUCMenu, ulBuffetID, hmodBuffet' return='-' .
  12840. // :fparams.
  12841. // :fparam name='hParent' type='HWND' io='input' .
  12842. // Parent of the dialog.
  12843. // :fparam name='hUCMenu' type='HWND' io='input' .
  12844. // Handle of the ucmenu to modify.
  12845. // :fparam name='ulBuffetID' type='ULONG' io='input' .
  12846. // ID of the buffet menu.
  12847. // :fparam name='hmodBuffet' type='HMODULE' io='input' .
  12848. // Module where the buffet menu is.
  12849. // :freturns.
  12850. // :fparam name='ulResult' type='ULONG' io='return'.
  12851. // result of WinDglBox
  12852. // :efparams.
  12853. // :remarks.
  12854. // :related.
  12855. // :efunction.
  12856. //----------------------------------------------------------------------------
  12857.  
  12858. ULONG APIENTRY UCMenuResourceBuffetDlg( HWND hParent, HWND hUCMenu, ULONG ulBuffetID, HMODULE hmodBuffet)
  12859. {
  12860.    #if defined(UCMUI)  // Only build this code if we support a user interface
  12861.    UCMDLGINFO UCMDlgInfo;
  12862.    ULONG      ulResult = 0;
  12863.    PUCMDATA   UCMData = (PUCMDATA)WinQueryWindowULong( hUCMenu, QWL_UCMDATA );
  12864.  
  12865.    if ( UCMData ){
  12866.       memset( &UCMDlgInfo, '\0', sizeof( UCMDLGINFO ) );
  12867.  
  12868.       UCMDlgInfo.ulSize         = sizeof( UCMDLGINFO );
  12869.       UCMDlgInfo.hwndUCMenu     = hUCMenu;
  12870.       UCMDlgInfo.UCMData        = UCMData;
  12871.       UCMDlgInfo.ulBuffetMenuID = ulBuffetID;
  12872.       UCMDlgInfo.hmodBuffetMenu = hmodBuffet;
  12873.       UCMDlgInfo.bFromTemplate  = FALSE;
  12874.       ulResult = WinDlgBox( hParent,
  12875.                   WinQueryWindow( hUCMenu, QW_OWNER ),
  12876.                   UCMDlgProc,
  12877.                   UCMData->hModUCM,
  12878.                   IDD_UCMDLG,
  12879.                   (PVOID)&UCMDlgInfo );
  12880.    } /* endif */
  12881.    return ulResult;
  12882.    #endif
  12883.    return DID_CANCEL;  // Return dummy value
  12884. }
  12885.  
  12886. #if defined(UCMUI)
  12887. //----------------------------------------------------------------------------
  12888. // UCMenuTemplateBuffetDlg
  12889. //----------------------------------------------------------------------------
  12890. // :function res=&IDF_TMPLBUFFETDLG. name='UCMenuTemplateBuffetDlg' text='Toolbar customization dialog'.
  12891. // This dialog let the user pick items from a buffet toolbar coming from a template..
  12892. // :syntax name='UCMenuTemplateBuffetDlg' params='hParent, hUCMenu, pTemplate' return='-' .
  12893. // :fparams.
  12894. // :fparam name='hParent' type='HWND' io='input' .
  12895. // Parent of the dialog.
  12896. // :fparam name='hUCMenu' type='HWND' io='input' .
  12897. // Handle of the ucmenu to modify.
  12898. // :fparam name='pTemplate' type='PVOID' io='input' .
  12899. // Template of the buffet menu
  12900. // :freturns.
  12901. // :fparam name='ulResult' type='ULONG' io='return'.
  12902. // result of WinDglBox
  12903. // :efparams.
  12904. // :remarks.
  12905. // :related.
  12906. // :efunction.
  12907. //----------------------------------------------------------------------------
  12908.  
  12909. ULONG APIENTRY UCMenuTemplateBuffetDlg( HWND hParent, HWND hUCMenu, PVOID pTemplate )
  12910. {
  12911.    #if defined(UCMUI)  // Only build this code if we support a user interface
  12912.    UCMDLGINFO UCMDlgInfo;
  12913.    HWND       hBuffet;
  12914.    ULONG      ulResult = 0;
  12915.    PUCMDATA UCMData = (PUCMDATA)WinQueryWindowULong( hUCMenu, QWL_UCMDATA );
  12916.  
  12917.    if ( UCMData ){
  12918.       memset( &UCMDlgInfo, '\0', sizeof( UCMDLGINFO ) );
  12919.  
  12920.       UCMDlgInfo.ulSize         = sizeof( UCMDLGINFO );
  12921.       UCMDlgInfo.hwndUCMenu     = hUCMenu;
  12922.       UCMDlgInfo.hwndBuffet     = hBuffet;
  12923.       UCMDlgInfo.UCMData        = UCMData;
  12924.       UCMDlgInfo.pTemplate      = pTemplate;
  12925.       UCMDlgInfo.bFromTemplate  = TRUE;
  12926.       ulResult = WinDlgBox( hParent,
  12927.         WinQueryWindow( hUCMenu, QW_OWNER ),
  12928.         UCMDlgProc,
  12929.         UCMData->hModUCM,
  12930.         IDD_UCMDLG,
  12931.         (PVOID)&UCMDlgInfo );
  12932.    } /* endif */
  12933.    return ulResult;
  12934.    #endif
  12935.    return DID_CANCEL;  // Return dummy value
  12936. }
  12937. #endif // UCMUI
  12938.  
  12939. //----------------------------------------------------------------------------
  12940. // UCMenuGetVersion
  12941. //----------------------------------------------------------------------------
  12942. // :function res=&IDF_GETVER. name='UCMenuGetVersion' text='Get the version of the toolbar'.
  12943. // This function returns the version of the ucmenus code.
  12944. // :syntax name='UCMenuGetVersion' params='-' return='ulVersion' .
  12945. // :fparams.
  12946. // :freturns.
  12947. // :fparam name='ulVersion' type='ULONG' io='return'.
  12948. // version of the ucmenus.
  12949. // :efparams.
  12950. // :remarks.
  12951. // :related.
  12952. // :efunction.
  12953. //----------------------------------------------------------------------------
  12954.  
  12955. ULONG APIENTRY UCMenuGetVersion()
  12956. {
  12957.    return (ULONG) UCMENUS_VERSION;
  12958.  
  12959. }
  12960.  
  12961.  
  12962. #if defined(UCMUI)
  12963. //----------------------------------------------------------------------------
  12964. // UCMenuLoadResBmp
  12965. //----------------------------------------------------------------------------
  12966. // :pfunction res=&IDF_LOADRESBMP. name='UCMenuLoadResBmp' text='Load the built-in bitmaps'.
  12967. // This function loads the built-in bitmap in the resource bitmaps dialog toolbar
  12968. // It is started by ResBmpDlgProc in a second thread.
  12969. // :syntax name='UCMenuLoadResBmp' params='pArgs' return='-' .
  12970. // :fparams.
  12971. // :fparam name='pArgs' type='PVOID' io='input' .
  12972. // Points to &colon.
  12973. // :dl compact.
  12974. // :dt.hwnd
  12975. // :dd.HWND, handle of the calling dialog.
  12976. // :dt.pID
  12977. // :dd.PULONG, points to the bitmap ids, freed by UCMenuLoadResBmp
  12978. // :dt.ulNb
  12979. // :dd.ULONG, number of  bitmap ids.
  12980. // :dt.hwndMenu
  12981. // :dd.HWND, handle of the toolbar menu
  12982. // Freed by UCMenuLoadResBmp
  12983. // :freturns.
  12984. // :fparam name='-' type='VOID' io='-'.
  12985. // Nothing
  12986. // :efparams.
  12987. // :remarks.
  12988. // The calling convention must be _System because this function
  12989. // is used in a DosCreateThread.
  12990. // :related.
  12991. // :epfunction.
  12992. //----------------------------------------------------------------------------
  12993. VOID _System UCMenuLoadResBmp( PVOID pArgs )
  12994. {
  12995.    if ( pArgs ){
  12996.       int      i;
  12997.       ULONG    ulNbId, ulH, ulW;
  12998.       PULONG   pId;
  12999.       MENUITEM mi;
  13000.       HWND     hwnd, hwndText, hwndButton, hwndUCM, hwndMenu;
  13001.       PUCMDATA UCMData;
  13002.       HAB      hab;
  13003.       HMQ      hmq;
  13004.       SWP      swp, swp2;
  13005.  
  13006.       hab = WinInitialize(0);
  13007.      hmq = WinCreateMsgQueue( hab, 0 );
  13008.  
  13009.       // Get hwnd
  13010.       hwnd = *( (HWND*)pArgs );
  13011.       // Get pId
  13012.       pId = *( (PULONG*)( (PBYTE)pArgs + sizeof( HWND ) ) );
  13013.       // Get ulNbId;
  13014.       ulNbId = *( (PULONG)( (PBYTE)pArgs + sizeof( HWND ) + sizeof( PULONG ) ) );
  13015.       // Get hwndMenu
  13016.       hwndMenu = *( (PHWND)( (PBYTE)pArgs + sizeof( HWND ) + sizeof( PULONG ) + sizeof( ULONG ) ) );
  13017.  
  13018.       UCMData = (PUCMDATA)WinQueryWindowULong( hwnd, QWL_USER );
  13019.  
  13020.       hwndUCM  = WinWindowFromID( hwnd, 7 ); // 7 is the magic bitmaps ucmenu ID
  13021.  
  13022.       for ( i = 0; i < ulNbId; i++ ){
  13023.          memset( &mi, '\0', sizeof mi );
  13024.          mi.iPosition = MIT_END;
  13025.          mi.afStyle   = MIS_OWNERDRAW;
  13026.          mi.id = UCMenuGetNewID( hwndMenu, MIT_NONE, (PUCMDATA)WinQueryWindowULong( hwndMenu, QWL_USER ) ) + 1;
  13027.          mi.hItem = (LONG)MyMalloc( sizeof( UCMITEM ) );
  13028.          if ( mi.hItem ){
  13029.             CHAR szId[22];
  13030.             sprintf( szId, "%i", pId[i] );
  13031.             memset( (PVOID)mi.hItem, 0, sizeof( UCMITEM ) );
  13032.             ITEM( &mi, pszBmp ) = MyMalloc( strlen( szId ) + 1 );
  13033.             strcpy( ITEM( &mi, pszBmp ), szId );
  13034.             WinSendMsg( hwndUCM, MM_INSERTITEM, MPFROMP( &mi ), MPFROMP( "" ) );
  13035.          } // endif
  13036.       } // endfor
  13037.       MyFree( pId );
  13038.  
  13039.       // query ucmenu size
  13040.       WinSendMsg( hwndUCM, UCMENU_QUERYSIZE, MPFROMP( &ulW ), MPFROMP( &ulH ) );
  13041.  
  13042.       // query dialog size
  13043.       WinQueryWindowPos( hwnd, &swp );
  13044.       hwndText   = WinWindowFromID( hwnd, IDC_RESBMPTEXT );
  13045.       hwndButton = WinWindowFromID( hwnd, IDB_RESBMPCANCEL );
  13046.       WinQueryWindowPos( hwndButton, &swp2 );
  13047.  
  13048.       // size window
  13049.       WinSetWindowPos( hwnd, HWND_TOP, 0, 0, swp.cx, ulH + swp2.y + swp2.cy + 50,  SWP_SIZE );
  13050.  
  13051.       // position static text
  13052.       WinSetWindowPos( hwndText, HWND_TOP,
  13053.                        5, swp2.y, swp2.x - 10, swp2.cy, SWP_MOVE | SWP_SHOW | SWP_SIZE );
  13054.  
  13055.       // position, size and show ucm
  13056.       WinSetWindowPos( hwndUCM, HWND_TOP, 10, swp2.y + swp2.cy + 10, swp.cx - 20, ulH, SWP_MOVE | SWP_SHOW | SWP_SIZE );
  13057.  
  13058.       // show window
  13059.       WinSetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOW  );
  13060.  
  13061.       // Set text
  13062.       WinSetDlgItemText( hwnd, IDC_RESBMPTEXT, nlsgetmessage( WinQueryAnchorBlock( hwnd ), UCMData->hModUCM, NLS_BMPLOADED, 0 ) );
  13063.  
  13064.       MyFree( pArgs );
  13065.  
  13066.       WinDestroyMsgQueue( hmq );
  13067.       WinTerminate( hab );
  13068.    } // endif pArgs
  13069. }
  13070. #endif // UCMUI
  13071.  
  13072. //----------------------------------------------------------------------------
  13073. // SubMemStrdup
  13074. //----------------------------------------------------------------------------
  13075. // :pfunction res=&IDF_SUBMEMSTRDUP. name='SubMemStrdup' text='strdup in a memory pool'.
  13076. // Does a strdup in a memory pool.
  13077. // :syntax name='SubMemStrdup' params='pSubMem, pszSource' return='pszTarget' .
  13078. // :fparams.
  13079. // :fparam name='pSubMem' type='PVOID' io='input' .
  13080. // Pointer to the memory pool.
  13081. // :fparam name='pszSource' type='PSZ' io='input' .
  13082. // String to be duplicated.
  13083. // :freturns.
  13084. // :fparam name='pszTarget' type='PSZ' io='return'.
  13085. // Duplicated string or 0 if failure.
  13086. // :efparams.
  13087. // :remarks.
  13088. // :epfunction.
  13089. //----------------------------------------------------------------------------
  13090. PSZ   _Optlink SubMemStrdup(PVOID pSubMem, PSZ pszSource)
  13091. {
  13092.    if (pszSource) {
  13093.       ULONG ul=0;
  13094.       PSZ pszDest=0;
  13095.       ul = strlen(pszSource);
  13096.       if ( !DosSubAllocMem( pSubMem, (PVOID)&pszDest, ul+1 ) ){
  13097.          strcpy(pszDest,pszSource);
  13098.          return pszDest;
  13099.       } // endif
  13100.    } // endif
  13101.    return NULL;
  13102. }
  13103.  
  13104.  
  13105. //----------------------------------------------------------------------------
  13106. // UCMenuAlloc
  13107. //----------------------------------------------------------------------------
  13108. // :function res=&IDF_UCMALLOC. name='UCMenuAlloc' text='Malloc used by the ucmenus'.
  13109. // External entry point to the allocation routine used by the ucmenus.
  13110. // :syntax name='UCMenuAlloc' params='size' return='PVOID' .
  13111. // :fparams.
  13112. // :fparam name='size' type='size_t' io='input' .
  13113. // Size to allocate.
  13114. // :freturns.
  13115. // :fparam name='pMem' type='PVOID' io='return'.
  13116. // Pointer to the allocated memory or 0 if failure.
  13117. // :efparams.
  13118. // :remarks.
  13119. // :related.
  13120. // :efunction.
  13121. //----------------------------------------------------------------------------
  13122. PVOID APIENTRY UCMenuAlloc(size_t size)
  13123. {
  13124.    return MyMalloc( size );
  13125. }
  13126.  
  13127. //----------------------------------------------------------------------------
  13128. // UCMenuStrdup
  13129. //----------------------------------------------------------------------------
  13130. PSZ  APIENTRY UCMenuStrdup(const char *Src)
  13131. {
  13132.  
  13133.    return MyStrdup(Src);
  13134. }
  13135.  
  13136.  
  13137. //----------------------------------------------------------------------------
  13138. // UCMenuItemFree
  13139. //----------------------------------------------------------------------------
  13140. // Complement to UCMenuItemDup() function
  13141. //----------------------------------------------------------------------------
  13142. VOID APIENTRY UCMenuItemFree(UCMITEM *Source)
  13143. {
  13144.   if (Source != NULL) {
  13145.     /* Free strings */
  13146.     if (Source->pszBmp != NULL)
  13147.       MyFree(Source->pszBmp);
  13148.     if (Source->pszText != NULL)
  13149.       MyFree(Source->pszText);
  13150.     if (Source->pszAction != NULL)
  13151.       MyFree(Source->pszAction);
  13152.     if (Source->pszParameters != NULL)
  13153.       MyFree(Source->pszParameters);
  13154.     if (Source->pszData != NULL)
  13155.       MyFree(Source->pszData);
  13156.  
  13157.     /* Free structure */
  13158.     MyFree(Source);
  13159.   }
  13160. }
  13161.  
  13162. //----------------------------------------------------------------------------
  13163. // UCMenuItemDup
  13164. //----------------------------------------------------------------------------
  13165. UCMITEM * APIENTRY UCMenuItemDup(UCMITEM *Source)
  13166. {
  13167. UCMITEM *NewItem;
  13168.  
  13169.   NewItem=MyMalloc(sizeof(UCMITEM));
  13170.   if (NewItem != NULL) {
  13171.     memset(NewItem, 0x00, sizeof(UCMITEM));
  13172.     /* Dup strings */
  13173.     if (Source->pszBmp != NULL)
  13174.       NewItem->pszBmp = MyStrdup(Source->pszBmp);
  13175.     if (Source->pszText != NULL)
  13176.       NewItem->pszText = MyStrdup(Source->pszText);
  13177.     if (Source->pszAction != NULL)
  13178.       NewItem->pszAction = MyStrdup(Source->pszAction);
  13179.     if (Source->pszParameters != NULL)
  13180.       NewItem->pszParameters = MyStrdup(Source->pszParameters);
  13181.     if (Source->pszData != NULL)
  13182.       NewItem->pszData = MyStrdup(Source->pszData);
  13183.  
  13184.     /* Copy selected parts of the structure.  We do not */
  13185.     /* copy hBmp.                                       */
  13186.     NewItem->usId    = Source->usId;
  13187.     NewItem->ulFlags = Source->ulFlags;
  13188.   }
  13189.  
  13190.   return NewItem;
  13191. }
  13192.  
  13193. //----------------------------------------------------------------------------
  13194. // UCMenuFree
  13195. //----------------------------------------------------------------------------
  13196. // :function res=&IDF_UCMFREE. name='UCMenuFree' text='Free used by the ucmenus'.
  13197. // External entry point to the freeing routine used by the ucmenus.
  13198. // :syntax name='UCMenuFree' params='pMem' return='-' .
  13199. // :fparams.
  13200. // :fparam name='pMem' type='PVOID' io='input' .
  13201. // Pointer to free.
  13202. // :freturns.
  13203. // :fparam name='-' type='VOID' io='-'.
  13204. // Nothing.
  13205. // :efparams.
  13206. // :remarks.
  13207. // :related.
  13208. // :efunction.
  13209. //----------------------------------------------------------------------------
  13210.  
  13211. VOID  APIENTRY UCMenuFree(VOID * p)
  13212. {
  13213.    MyFree( p );
  13214. }
  13215.  
  13216.  
  13217.  
  13218. #ifdef UCMENUS_DEBUG
  13219.  
  13220.    #ifdef MYMALLOC_RIGHT_BOUNDARY
  13221.  
  13222.       #define MYPAGESIZE 4096lu
  13223.  
  13224.       VOID *   MyMalloc(size_t size)
  13225.       {
  13226.          // --------------------------------------------------------------
  13227.          // -- In case size+sizeof(ULONG) is on a page boundary, this code
  13228.          // -- will allocate one unnecessary supplemental page...
  13229.          // --------------------------------------------------------------
  13230.  
  13231.          PVOID p;
  13232.          ULONG ulSizeAllocated;
  13233.  
  13234.          ulSizeAllocated = (size+sizeof(ULONG)) - (size+sizeof(ULONG))%MYPAGESIZE + MYPAGESIZE;
  13235.  
  13236.          if (  DosAllocMem( &p, ulSizeAllocated, PAG_COMMIT | PAG_READ | PAG_WRITE) ) {
  13237.             return 0;
  13238.          }
  13239.          p =  ( PVOID ) ( ((PBYTE)p) + ulSizeAllocated  - size );
  13240.          *( ((PULONG)p)-1 ) = (ULONG)size;
  13241.          return p;
  13242.       }
  13243.  
  13244.       VOID  MyFree(VOID * p)
  13245.       {
  13246.          if (p) {
  13247.             ULONG ulSizeAllocated;
  13248.             ULONG ulSize = *( (PULONG)(p) -1 );
  13249.  
  13250.             ulSizeAllocated = (ulSize+sizeof(ULONG)) - (ulSize+sizeof(ULONG))%MYPAGESIZE + MYPAGESIZE;
  13251.             DosFreeMem( (PVOID) ( ((PBYTE)p) - ulSizeAllocated + ulSize ) );
  13252.          } // endif
  13253.       }
  13254.   #else
  13255.       VOID *   MyMalloc(size_t size)
  13256.       {
  13257.          PVOID p;
  13258.  
  13259.          if (DosAllocMem( &p, (ULONG) ( size ), PAG_COMMIT | PAG_READ | PAG_WRITE)) {
  13260.             return 0;
  13261.          }
  13262.          return p;
  13263.       }
  13264.  
  13265.  
  13266.       VOID  MyFree(VOID * p)
  13267.       {
  13268.          if (p) {DosFreeMem( (PVOID) ( p ));}
  13269.       }
  13270.   #endif // MY_MALLOC_RIGHT_BOUNDARY
  13271.  
  13272.    char * MyStrdup( const char * string)
  13273.    {
  13274.       if (string) {
  13275.          ULONG ul=0;
  13276.          char * stringDest = 0;
  13277.          ul = strlen(string);
  13278.          stringDest = MyMalloc(ul+1);
  13279.          if (stringDest) {
  13280.             strcpy(stringDest,string);
  13281.             return stringDest;
  13282.          } // endif
  13283.       } // endif
  13284.       return NULL;
  13285.    }
  13286. #else
  13287.    char * MyStrdup( const char * string)
  13288.    {
  13289.       if (string) {
  13290.          return strdup( string );
  13291.       } // endif
  13292.       return NULL;
  13293.    }
  13294.  
  13295. #endif // ifdef UCMENUS_DEBUG
  13296.  
  13297. //----------------------------------------------------------------------------
  13298. // nlsgetmessage
  13299. //----------------------------------------------------------------------------
  13300. // :pfunction res=&IDF_NLSGETMSG. name='nlsgetmessage' text='get a string from the string table'.
  13301. // Returns a string from the string table in a static buffer.
  13302. // :syntax name='nlsgetmessage' params='Hab, HModule, msg, buffnum' return='buffer' .
  13303. // :fparams.
  13304. // :fparam name='Hab' type='HAB' io='input' .
  13305. // Anchor block of the application.
  13306. // :fparam name='HModule' type='HMODULE' io='input' .
  13307. // Handle of the module where the string table is.
  13308. // :fparam name='msg' type='SHORT' io='input' .
  13309. // ID of the message to retrieve.
  13310. // :fparam name='buffnum' type='SHORT' io='input'.
  13311. //  Number of the buffer to use. (0-3)
  13312. // :freturns.
  13313. // :fparam name='buffer' type='PSZ' io='return'.
  13314. //  Pointer to the static buffer where the string is.
  13315. // :efparams.
  13316. // :remarks.
  13317. // Currently the indexes 0-2 are used for thread 1 and 3 for thread 2.
  13318. // :related.
  13319. // :epfunction.
  13320. //----------------------------------------------------------------------------
  13321. #define NLSSTRINGLEN   256
  13322. #define MAXNLSBUF 6
  13323. PSZ _Optlink nlsgetmessage(HAB Hab, HMODULE HModule, SHORT msg, SHORT buffnum )
  13324. {
  13325.    static UCHAR buffer[MAXNLSBUF][NLSSTRINGLEN];
  13326.  
  13327.    WinLoadString( Hab,
  13328.                   HModule,
  13329.                   msg,
  13330.                   NLSSTRINGLEN,
  13331.                   buffer[buffnum] );
  13332.  
  13333.    return buffer[buffnum];
  13334. }
  13335.  
  13336. /****************************************************************************/
  13337. LONG  _Optlink UCMString2Int(char *lpString, BOOL *lpTranslated)
  13338. /****************************************************************************/
  13339. /* Translate a string to binary value.  String may contain leading and      */
  13340. /* trailing blanks and optional minus sign.  An error occures if string     */
  13341. /* contains any non-numeric character other than leading/trailing blanks.   */
  13342. /* If an error occures, zero is returned and lpTranslated is set to FALSE   */
  13343. /* if supplied.  (If lpTranslated is a NULL pointer, zero is returned and   */
  13344. /* caller cannot know if an error occured).                                 */
  13345. /*                                                                          */
  13346. /****************************************************************************/
  13347. {
  13348.   char  *Buff = lpString;
  13349.   int    i    = 0;
  13350.   int    sign = 1;
  13351.   LONG   lReturn = 0L;
  13352.  
  13353.   /*-------------------------------------------------------------------------*/
  13354.   /*  check the buffer pointer                                               */
  13355.   /*-------------------------------------------------------------------------*/
  13356.   if (!lpString)                                
  13357.   {                                             
  13358.     if ( lpTranslated ) *lpTranslated = FALSE;  
  13359.     return 0L;
  13360.   }
  13361.  
  13362.   /*-------------------------------------------------------------------------*/
  13363.   /*  striping any extra spaces.                                             */
  13364.   /*-------------------------------------------------------------------------*/
  13365.   while ( Buff[i] == ' ' ) i++;
  13366.   if ( Buff[i] == '\0' )
  13367.   {
  13368.     if ( lpTranslated ) *lpTranslated = FALSE;
  13369.     return 0L;
  13370.   }
  13371.  
  13372.   /*-------------------------------------------------------------------------*/
  13373.   /*  check sign flag.                                                       */
  13374.   /*-------------------------------------------------------------------------*/
  13375.   if ( Buff[i] == '-' )
  13376.   {
  13377.     sign = -1;
  13378.     i++;
  13379.   }
  13380.  
  13381.   /*-------------------------------------------------------------------------*/
  13382.   /*  walk the number calculating as we go                                   */
  13383.   /*-------------------------------------------------------------------------*/
  13384.   while ( Buff[i]>='0' && Buff[i]<='9')
  13385.   {
  13386.     lReturn = (lReturn*10) + ((int)Buff[i] - (int)'0');
  13387.     i++;
  13388.   }
  13389.   while ( Buff[i] == ' ' ) i++;  // Ignore trailing blanks
  13390.   if ( Buff[i] != '\0' )         // Error if any more chars in string
  13391.   {
  13392.     if ( lpTranslated ) *lpTranslated = FALSE;
  13393.     return 0L;
  13394.   }
  13395.  
  13396.   /*-------------------------------------------------------------------------*/
  13397.   /*  return results                                                         */
  13398.   /*-------------------------------------------------------------------------*/
  13399.  
  13400.   if ( lpTranslated ) *lpTranslated = TRUE;
  13401.   return (sign * lReturn);
  13402. }
  13403.  
  13404.