home *** CD-ROM | disk | FTP | other *** search
/ Using the Internet / 21003.iso / email / PEGASUS / WINPM222.ZIP / WINPMAIL.ZIP / FORMS / WPMFORMS.H < prev    next >
Text File  |  1995-11-12  |  67KB  |  1,286 lines
  1. //
  2. //  WPMFORMS.H
  3. //  Definitions and constants for the Pegasus Mail for Windows
  4. //  Extensions Manager interface.
  5. //
  6. //  Copyright (c) 1994-95, David Harris, all rights reserved.
  7. //
  8.  
  9. //  Next available offset -
  10. //    -  For WM_FM_*      =   11    (29 Aug '95)
  11. //    -  For WM_F_*       =   76    (2 Nov '95)
  12.  
  13. //  Flag constants:
  14.  
  15. #define WPM_STARTUP     1     // Extension wants to be loaded at startup
  16. #define WPM_NOLIST      2     // Do not show extension in Form Manager list
  17. #define WPM_HIDDEN      4     // Do not display extension's parent window
  18. #define WPM_LOGGING     8     // Extension wants to receive logging events
  19. #define WPM_ONEONLY     16    // Disallow multiple simultaneous instances
  20. #define WPM_FIRSTRUN    32    // Autoload extension on first-ever WinPMail run
  21.  
  22. #define WPM_PROHIBIT    0x9999L
  23.  
  24. //  Form dialogs and callbacks: a form DLL can export a function
  25. //  which WinPMail's form manager will call with Windows messages
  26. //  destined for the form's dialog or window (such as menu selections
  27. //  and so forth). The function takes the following form:
  28.  
  29. typedef long FAR PASCAL (*FORM_CALLBACK) (HWND hWnd, UINT wMsg,
  30.    WPARAM wParam, LPARAM lParam);
  31.  
  32. //  The return from a form callback is passed back through the
  33. //  Windows call chain if non-zero, otherwise the default window
  34. //  proc is called.
  35.  
  36. //  Minimum interface: the minimum interface a form DLL must provide
  37. //  is a routine called "FORMINIT" which is exported by name. "FORMINIT"
  38. //  has the following prototype:
  39.  
  40. typedef WORD FAR PASCAL (*FN_FORMINIT) (WORD version, int variant, 
  41.    HWND hParent, char *data, HWND *hDialog, char *callback_name);
  42.  
  43. //  "version" is passed in with the version of the WinPMail forms
  44. //     manager which is running.
  45. //  "variant" indicates what type of form is required - the following
  46. //     values are currently defined:
  47. //       0: Create a form for composing a message
  48. //       1: Create a form for reading a message
  49. //  "hParent" contains the handle of the WinPMail MDI child window
  50. //     which is to contain the form.
  51. //  "data" contains any string defined as being required for the
  52. //     form in the menu interface.
  53. //  "hDialog" should be filled in with the window handle of the
  54. //     modeless dialog created within the MDI child window. If the
  55. //     value returned is NULL, then the MDI child window will be
  56. //     hidden and will never actually interact directly with the
  57. //     user, but the extension will still receive messages from the
  58. //     Form Manager and can still send messages to its parent for
  59. //     access to API functions.
  60. //  "callback_name" (optional) should be filled in with the name of the
  61. //     function in the DLL of the exported function to which messages
  62. //     should be sent or NULL if there is none. If NULL, messages are
  63. //     sent to the dialog returned in "hDialog". You will use an
  64. //     indirect callback of this kind when your extension does not
  65. //     create a dialog within the enclosing parent window.
  66. //
  67. //  When FORMINIT is called, the DLL should create the dialog within
  68. //  the MDI parent window and set it to the correct size. On return
  69. //  WinPMail will resize the parent window to enclose the dialog
  70. //  correctly. The DLL should NOT make the dialog visible - WinPMail
  71. //  will do that as required.
  72.  
  73. //
  74. // +--------------------------------------------------------------------+
  75. // |  SECTION 1:                                                        |
  76. // |  Messages the Extension Manager can send to an extension:          |
  77. // +--------------------------------------------------------------------+
  78. //
  79.  
  80. #define WM_FM_FORMBASE           (WM_USER + 1800)
  81.  
  82. #define WM_FM_INIT               (WM_FM_FORMBASE + 1)
  83. //  Sent by the manager after the MDI parent window has been created
  84. //  and FORMINIT has been called, but before any positioning has been
  85. //  done. At the time this message arrives, the window will not be
  86. //  visible on the screen. An extension may send any extension manager
  87. //  message while processing this message and at any time afterwards.
  88.  
  89. #define WM_FM_SIZE               (WM_FM_FORMBASE + 2)
  90. //  Sent by the manager when the enclosing MDI window is resized.
  91. //  The parameters from the WM_SIZE message passed by windows are
  92. //  sent through unaltered. If an extension contains a dialog, it
  93. //  should resize the dialog to the MDI parent window size in
  94. //  response to this message.
  95.  
  96. #define WM_FM_GETMINMAXINFO      (WM_FM_FORMBASE + 3)
  97. //  Sent by the manager when Windows asks it for the limits on a
  98. //  window resize operation. See the Windows documentation for
  99. //  WM_GETMINMAXINFO for more details (the manager passes the
  100. //  parameters through unmodified).
  101.  
  102. #define WM_FM_WHEREYAWANNIT       (WM_FM_FORMBASE + 4)
  103. //  Sent by the forms manager after creating the form dialog but before
  104. //  displaying the MDI child window; asks where the form would like its
  105. //  window placed on the screen. lParam points to a POINT structure;
  106. //  if 1 is returned, the position it contains will be used. The position
  107. //  should be expressed in units from the top left corner of WinPMail's
  108. //  main client area. If 0 is returned, WinPMail will stagger the window
  109. //  like any other of its own windows. If 2 is returned, WinPMail will
  110. //  centre the window in the client area.
  111.  
  112. #define WM_FM_INITFOCUS           (WM_FM_FORMBASE + 5)
  113. //  Sent by the manager at the end of Window creation, after the
  114. //  window has been made visible. The dialog should set focus to
  115. //  whichever control it wishes.
  116.  
  117. #define WM_FM_RESTOREFOCUS        (WM_FM_FORMBASE + 6)
  118. //  Sent by the manager any time the window should restore its
  119. //  focus to the last active control. This curiosity is needed
  120. //  because of a glitch in the way Windows handles focus for
  121. //  dialogs embedded in MDI children. Dialogs should record the
  122. //  last active control by trapping EN_SETFOCUS messages from
  123. //  the controls they contain.
  124.  
  125. #define WM_FM_COMMAND             (WM_FM_FORMBASE + 7)
  126. //  The Manager generates a WM_FM_COMMAND message any time it
  127. //  receives a WM_COMMAND message which it cannot itself handle.
  128. //  In almost all cases, this will occur with menu selections
  129. //  from the main WinPMail menu. The format of this command is
  130. //  exactly the same as a WM_COMMAND message.
  131. //
  132. //  The following predefined values should be used to decode
  133. //  WM_FM_COMMAND messages: you should avoid using any of these
  134. //  values in any menu you create.
  135. #define IDM_PRINT            107      //  Print the current contents
  136. #define IDM_UNDO             131      //  User selected "undo"
  137. #define IDM_CUT              132      //  User selected "cut"
  138. #define IDM_COPY             133      //  User selected "copy"
  139. #define IDM_PASTE            134      //  User selected "paste"
  140. #define IDM_CLEAR            135      //  User selected "clear"
  141. #define IDM_SELECTALL        136      //  User selected "select all"
  142. #define IDM_SPELLING         137      //  User asked to check spelling
  143. #define IDM_TODISK           230      //  User clicked the "to disk" bp icon
  144. #define IDM_FROMDISK         231      //  User clicked the "from disk" bp icon
  145. #define IDM_FONT             299      //  User clicked the "font" bp icon
  146.  
  147. #define WM_FM_DROPMESSAGE         (WM_FM_FORMBASE + 10)
  148. //  Sent by the Extensions Manager when it is advised that a message
  149. //  has been dropped somewhere on the extension's window. lParam
  150. //  contains a pointer to the point in the window where the drop occurred.
  151. //  Once an extension receives this message, it may use any of the messages
  152. //  in section 4 (Reader Extension Messages) to access the message which has
  153. //  been dropped onto it, but only up to the point at which it returns
  154. //  control to the Extension Manager.
  155.  
  156.  
  157. //
  158. // +--------------------------------------------------------------------+
  159. // |  SECTION 2:                                                        |
  160. // |  Messages a form can send to the Forms Manager to access           |
  161. // |  internal Pegasus Mail messaging services:                         |
  162. // +--------------------------------------------------------------------+
  163. //
  164.  
  165. #define WM_F_FORMBASE            (WM_USER + 2000)
  166.  
  167. #define WM_F_QUICKADDRESS        (WM_F_FORMBASE + 1)
  168. //  Open the Recent address list and allow the user to select
  169. //  addresses from it. Any addresses selected are pasted into the
  170. //  EDIT control specified in wParam.
  171. //  ** PARAMETERS: wParam = Active edit control;  lParam = unused
  172. //  ** RETURNS:    Nothing
  173.  
  174. #define WM_F_NEWMESSAGE          (WM_F_FORMBASE + 2)
  175. //  Create a new message ready to be filled out. NOTE: this does not
  176. //  mean "open a new mail composition window", it merely means "I am
  177. //  about to generate a message for you to send - get ready", and
  178. //  causes the Extension Manager to create internal data structures.
  179. //  Note that this function will also "reset" the message structure
  180. //  associated with an extension window if a message has already been
  181. //  started or sent, clearing all addresses, custom headers and other
  182. //  defined fields.
  183. //  ** PARAMETERS: None
  184. //  ** RETURNS:    1 on success, 0 on failure (out of memory)
  185. //  ** WARNING:    You MUST send this message before attempting to
  186. //                 fill out any fields in a message.
  187.  
  188. #define WM_F_TO                  (WM_F_FORMBASE + 3)
  189. //  Set the "To" field of the message
  190. //  ** PARAMETERS: wParam = unused; lParam = address to set
  191. //  ** RETURNS:    Nothing
  192.  
  193. #define WM_F_CC                  (WM_F_FORMBASE + 4)
  194. //  Set the "Cc" field of the message
  195. //  ** PARAMETERS: wParam = unused; lParam = address to set
  196. //  ** RETURNS:    Nothing
  197.  
  198. #define WM_F_BCC                 (WM_F_FORMBASE + 5)
  199. //  Set the "BCc" field of the message
  200. //  ** PARAMETERS: wParam = unused; lParam = address to set
  201. //  ** RETURNS:    Nothing
  202.  
  203. #define WM_F_SUBJECT             (WM_F_FORMBASE + 6)
  204. //  Set the "Subject" field of the message
  205. //  ** PARAMETERS: wParam = unused; lParam = text to set
  206. //  ** RETURNS:    Nothing
  207.  
  208. #define WM_F_COPYSELF            (WM_F_FORMBASE + 7)
  209. //  Set the message's Copy-to-self flag
  210. //  ** PARAMETERS: wParam = 1 or 0; lParam = unused
  211. //  ** RETURNS:    Nothing
  212.  
  213. #define WM_F_CONFIRMREADING      (WM_F_FORMBASE + 8)
  214. //  Set the message's Confirm-reading flag
  215. //  ** PARAMETERS: wParam = 1 or 0; lParam = unused
  216. //  ** RETURNS:    Nothing
  217.  
  218. #define WM_F_CONFIRMDELIVERY     (WM_F_FORMBASE + 9)
  219. //  Set the message's Confirm-delivery flag
  220. //  ** PARAMETERS: wParam = 1 or 0; lParam = unused
  221. //  ** RETURNS:    Nothing
  222.  
  223. #define WM_F_URGENT              (WM_F_FORMBASE + 10)
  224. //  Set the message's Urgent flag
  225. //  ** PARAMETERS: wParam = 1 or 0; lParam = unused
  226. //  ** RETURNS:    Nothing
  227.  
  228. #define WM_F_MIME                (WM_F_FORMBASE + 11)
  229. //  Set the message's Use-MIME flag
  230. //  ** PARAMETERS: wParam = 1 (use MIME) or 0 (Don't); lParam = unused
  231. //  ** RETURNS:    Nothing
  232.  
  233. #define WM_F_8BITDATA            (WM_F_FORMBASE + 62)
  234. //  Set/unset the flag which controls whether or not a message
  235. //  can be sent via Internet transports using raw 8-bit data.
  236. //  ** PARAMETERS: wParam = 1 (allow 8 bits) or 0 (don't); lParam = unused
  237. //  ** RETURNS:    Nothing
  238. //  Note: 8-bit data is officially illegal in Internet mail - you are
  239. //    <<strongly>> urged not to use this option unless you have no other
  240. //    choice and understand very clearly what you are doing. The author
  241. //    accepts no responsibility whatsoever for abuse of this feature and
  242. //    reserves the right to remove or disable it in future releases of
  243. //    the program if it is indiscriminately or carelessly used.
  244.  
  245. #define WM_F_REPLYTO             (WM_F_FORMBASE + 12)
  246. //  Set the "Reply-to" field of the message
  247. //  ** PARAMETERS: wParam = unused; lParam = address to set
  248. //  ** RETURNS:    Nothing
  249.  
  250. #define WM_F_ATTACH              (WM_F_FORMBASE + 13)
  251. //  Add an attachment to the message:
  252. //  ** PARAMETERS: wParam = unused;
  253. //     lParam points to a record of the following type:
  254. #ifndef WINPMAIL
  255. typedef struct
  256.    {
  257.    char file_to_attach [144];
  258.    char attachment_type [32];
  259.    char encoding;
  260.    } ATTACHMENT;
  261. #endif
  262. //  "encoding" can be:
  263. //     0: Best guess - WinPMail chooses the most appropriate encoding
  264. //     1: No encoding (use with EXTREME care)
  265. //     2: ASCII text
  266. //     3: UUencoding
  267. //     4: BinHex
  268. //     5: MIME encoding (BASE64)
  269. //  You are <<strongly>> encouraged to set "encoding" to 0 unless you
  270. //  are VERY sure of what you are doing.
  271. //  ** RETURNS:    Nothing
  272.  
  273. #define WM_F_ENCRYPTIONKEY       (WM_F_FORMBASE + 14)
  274. //  Set the encryption key for the message; if 0-length, the message
  275. //  is not encrypted.
  276. //  ** PARAMETERS: wParam = unused; lParam points to encryption key
  277. //  ** RETURNS:    Nothing
  278.  
  279. #define WM_F_NOSIG               (WM_F_FORMBASE + 15)
  280. //  Set the message's No-signature flag; wParam = 1 or 0
  281. //  ** PARAMETERS: wParam = 1 (no signature) or 0; lParam = unused
  282. //  ** RETURNS:    Nothing
  283. //  ** Note the reversed sense of the wParam parameter.
  284.  
  285. #define WM_F_MESSAGEFILE         (WM_F_FORMBASE + 16)
  286. //  Indicate the full path to a file containing the text Pegasus Mail
  287. //  should use as the body of the mail message.
  288. //  ** PARAMETERS: wParam = unused; lParam = pointer to path (C string)
  289. //  ** RETURNS:    Nothing
  290. //  ** Note: this message and WM_F_MESSAGETEXT are mutually exclusive.
  291. //  ** Note 2: the variable pointed to by lParam should be persistent -
  292. //     that is, its value should remain valid until the message is sent.
  293. //     Pegasus Mail stores the pointer, not a copy of the data, so if you
  294. //     allocate the path on the stack the return from the function where
  295. //     it is declared, it will be trashed. In general, either allocate
  296. //     memory for it explicitly or declare it static. If you allocate
  297. //     memory for it, remember to release it, since WinPMail will not.
  298.  
  299. #define WM_F_MESSAGETEXT         (WM_F_FORMBASE + 17)
  300. //  Set the text of the mail message body to a block contained in memory.
  301. //  Lines should end in LF characters only. lParam points to the text,
  302. //  which must be nul-terminated.
  303. //  ** PARAMETERS: wParam = unused; lParam = pointer to textual data.
  304. //  ** RETURNS:    Nothing
  305. //  ** Note: this message and WM_F_MESSAGEFILE are mutually exclusive.
  306. //  ** Note 2: you can get text from an edit control formatted in the
  307. //     proper way for this message using the WM_F_GETTEXT message.
  308.  
  309. #define WM_F_EXPIRATION          (WM_F_FORMBASE + 18)
  310. //  Set the expiration date of the message
  311. //  ** PARAMETERS: wParam = unused; lParam = pointer to a 7-byte
  312. //     date format record described under WM_F_GETDATETIME below.
  313. //  ** RETURNS:    Nothing
  314.  
  315. #define WM_F_SETDEFAULTS         (WM_F_FORMBASE + 19)
  316. //  Initialize a message created using the WM_F_NEWMESSAGE menu to
  317. //  the values stored in the user's preferences file. You should send
  318. //  this message after sending WM_F_NEWMESSAGE but before sending any
  319. //  other messagefield-related message.
  320. //  ** PARAMETERS: wParam = unused; lParam = unused
  321. //  ** RETURNS:    Nothing
  322.  
  323. #define WM_F_SETHEADER           (WM_F_FORMBASE + 61)
  324. //  Set a custom header in the outgoing message. lParam points to
  325. //  the header data, and wParam is either 0 if the header is suitable
  326. //  for use in RFC822 messages or 1 if the header is intended for use
  327. //  in MHS messages. This routine cannot be used to alter the following
  328. //  headers in the message: "From:", "To:", "Reply-to:", "Cc:", "Bcc:",
  329. //  "Subject:", "Date:", "X-To:", "Copies-to:", "Organization:",
  330. //  "Priority:", "Importance:", or "Sender:" - attempting to do so will
  331. //  return an error code. Any other legally formatted header may be
  332. //  added, though; the header may contain LFs to indicate line breaks
  333. //  (note, do NOT add the CR) but must follow proper line folding rules
  334. //  for the destination transport. The header need not end with a newline
  335. //  character but may do so (WinPMail will add it if necessary).
  336. //  ** PARAMETERS: wParam = 0 (RFC822) or 1 (MHS); lParam = header.
  337. //  ** RETURNS:    1=Success, 0=illegal header, -1 = out of memory.
  338. //  ** WARNING:    This message is extremely specialised and should not
  339. //                 be needed in the vast majority of cases. You should
  340. //                 only use this message if you have expert knowledge
  341. //                 of the message transport for with the header you are
  342. //                 adding is intended.
  343.  
  344. #define WM_F_SENDMESSAGE         (WM_F_FORMBASE + 20)
  345. //  Send a message created using the interface defined in the
  346. //  preceding messages. It is legal to call this message repeatedly
  347. //  for the same message definition - so, if you wanted to send the
  348. //  same message to 20 different users, you could set it up the way
  349. //  you want it then call WM_F_TO after each WM_F_SENDMESSAGE call
  350. //  to change the recipient.
  351. //  ** PARAMETERS: wParam = unused; lParam = unused
  352. //  ** RETURNS:    0 on failure, 1 on success.
  353.  
  354.  
  355. //
  356. // +--------------------------------------------------------------------+
  357. // |  Section 3:                                                        |
  358. // |  Simple TCP/IP interface routines                                  |
  359. // +--------------------------------------------------------------------+
  360. //
  361. // The extensions manager provides a simplified TCP/IP interface to
  362. // extensions, suitable for simple question-and-answer style protocols
  363. // such as POP3, SMTP, Finger, LDAP or PH. The TCP/IP connection is
  364. // fully buffered and quite robust, but offers nothing fancy. An
  365. // extension can have up to five TCP/IP connections open at any time.
  366. // If you need more than this interface offers (UDP support, for
  367. // instance), you should load WINSOCK.DLL using your own instance
  368. // handle and access its services directly.
  369. //
  370. // Note: WinPMail's socket handling is fully non-blocking so you can
  371. // open multiple sockets simultaneously without contention problems.
  372. // The exception to this is name resolution calls, which may block,
  373. // and which may therefore cause transient failures. This will be
  374. // addressed in future, but for now the easiest way to avoid this
  375. // as a problem is to use numeric IP addresses instead of names
  376. // wherever possible.
  377.  
  378. #define WM_F_TCPOPEN             (WM_F_FORMBASE + 29)
  379. //  Open a TCP/IP connection
  380. //  ** PARAMETERS: wParam = host port; lParam = pointer to host
  381. //     address in either domain name or dotted-IP format.
  382. //  ** RETURNS:    -1 on failure
  383.  
  384. #define WM_F_TCPGETS             (WM_F_FORMBASE + 34)
  385. //  Get a line of data from an open TCP/IP port. The terminating LF or
  386. //  CR/LF is not removed from the returned data.
  387. //  ** PARAMETERS: wParam = length of buffer; lParam = pointer to buffer
  388. //  ** RETURNS:    > 0 = OK; 0 = timeout; < 0; TCP/IP error
  389.  
  390. #define WM_F_TCPPUTS             (WM_F_FORMBASE + 35)
  391. //  Write a line of data to an open TCP/IP port; does not add CRLF. The
  392. //  data is presumed to be a nul-terminated C string.
  393. //  ** PARAMETERS: wParam = unused; lParam = pointer to data to write
  394. //  ** RETURNS:    > 0 = OK; 0 = timeout; < 0; TCP/IP error
  395.  
  396. #define WM_F_TCPCLOSE            (WM_F_FORMBASE + 36)
  397. //  Close an open TCP/IP connection
  398. //  ** PARAMETERS: wParam = unused; lParam = unused
  399. //  ** RETURNS:    -1 on failure
  400.  
  401. #define WM_F_TCPPRESENT          (WM_F_FORMBASE + 37)
  402. //  Determine whether TCP/IP services are available and configured
  403. //  ** PARAMETERS: wParam = unused; lParam = unused
  404. //  ** RETURNS:    1 = OK to use TCP/IP services; 0 = no TCP/IP services
  405.  
  406. #define WM_F_TCPMYNAME           (WM_F_FORMBASE + 38)
  407. //  Return the domain name of the current machine. If no domain name
  408. //  can be determined, return the machine's IP address in dotted format.
  409. //  ** PARAMETERS: wParam = length of buffer; lParam = pointer to buffer
  410. //  ** RETURNS:    Nothing
  411.  
  412. #define WM_F_TCPSETSOCKET        (WM_F_FORMBASE + 49)
  413. //  Set the socket which will be used in subsequent TCP/IP calls.
  414. //  The default socket is 0, so if you only ever have a single
  415. //  connection open at any time you will never need to use this
  416. //  message. Each extension (or instance of an extension) can have up
  417. //  to five connections open simultaneously and can select the one you
  418. //  are interested in using this message
  419. //  ** PARAMETERS: wParam = desired socket (0..4); lParam = unused
  420. //  ** RETURNS:    Nothing
  421.  
  422. #define WM_F_TCPPOP3             (WM_F_FORMBASE + 52)
  423. //  Initiate a regular POP3 connection and download mail to the
  424. //  local machine. If wParam is 0, a progress dialog will be put
  425. //  up during the transaction. If lParam is 0 (NULL) then the
  426. //  standard host configuration provided by the user will be used
  427. //  for host and username information; alternatively, lParam can
  428. //  point to a copy of the following structure:
  429. #ifndef PROFILE_INCLUDED
  430. #define MAXHOST 80
  431. typedef struct
  432.    {
  433.    char pop3host [MAXHOST];   //  POP3 server address
  434.    char smtphost [MAXHOST];   //  SMTP server address
  435.    char username [48];        //  POP3 account name
  436.    char password [48];        //  POP3 account password
  437.    char mask [64];            //  Path and filespec to find SMTP files
  438.    char mailbox [80];         //  Where to place incoming POP3 messages
  439.    long threshhold;           //  Largest message to download, in bytes
  440.    int delete_mail;           //  If NZ, delete successfully downloaded mail
  441.    long wflags;
  442.    char from_field [MAXHOST]; //  Contents of the message's "from" field
  443.    int timeout;               //  TCP/IP timeout (seconds)
  444.    char memory_file [14];     //  State info file when leaving mail on server
  445.    int pop3port;              //  Destination port on POP3 server
  446.    } POPDEF;
  447. //  The "wflags" field is a bitmap which can have the following values:
  448. #define POP_LEAVE_ON_SERVER 1      //  Download only unread mail
  449. #endif
  450. //
  451. //  ** PARAMETERS: wParam = 0/NZ;dialog/none; lParam = NULL/see above
  452. //  ** RETURNS:    None
  453.  
  454. #define WM_F_TCPOP3VERIFY        (WM_F_FORMBASE + 55)
  455. //  Initiate a regular POP3 connection but ONLY check that the
  456. //  user and password information supplied is valid. No actual
  457. //  mail transaction is performed. A dialog is never put up for
  458. //  this routine, although messages may appear on the statusline.
  459. //    If wParam is non-zero, the POP3 code will establish a con-
  460. //  nection to the POP3 server, will authenticate the user, and
  461. //  will then return control in the open state. If you use this
  462. //  feature, it is up to you to issue proper POP3 commands to
  463. //  manage the session and close it down gracefully.
  464. //    If lParam is 0 (NULL) then the standard host configuration
  465. //  provided by the user will be used for host and username
  466. //  information; alternatively, lParam can point to a copy of
  467. //  the POPDEF structure shown above.
  468. //  ** PARAMETERS: wParam = unused; lParam = NULL/see above
  469. //  ** RETURNS:    1 if the information is valid, 0 if not.
  470. //  ** Note: it is not possible to determine in any meaningful way
  471. //  which of the username or password was incorrect if verification
  472. //  fails, because most POP3 servers accept any username for security
  473. //  reasons.
  474.  
  475. #define WM_F_TCPOP3COUNT         (WM_F_FORMBASE + 56)
  476. //  Initiate a regular POP3 connection but ONLY count the number
  477. //  of messages waiting on the account. No actual mail download is
  478. //  performed and a dialog is never put up although messages may
  479. //  appear on the statusline. If lParam is 0 (NULL) then the
  480. //  standard host configuration provided by the user will be used
  481. //  for host and username information; alternatively, lParam can
  482. //  point to a copy of the POPDEF structure shown above.
  483. //  ** PARAMETERS: wParam = unused; lParam = NULL/see above
  484. //  ** RETURNS:    -1 on error, message count otherwise
  485.  
  486. #define WM_F_TCPSMTP             (WM_F_FORMBASE + 53)
  487. //  Initiate a regular SMTP connection using the built-in client.
  488. //    If wParam is 0, a progress dialog will be put up during the
  489. //  transaction. As with WM_F_TCPPOP3, you can pass a POPDEF
  490. //  structure pointer in lParam to specify an alternative host.
  491. //  ** PARAMETERS: wParam = 0/NZ;dialog/none; lParam = NULL/see above
  492. //  ** RETURNS:    None
  493. //  ** Note: for security reasons, WinPMail will only send mail using
  494. //  the SMTP protocol if it can verify your POP3 information by
  495. //  connecting to the specified POP3 server; no verification, no send.
  496.  
  497. #define WM_F_TCPREAD             (WM_F_FORMBASE + 59)
  498. //  Read raw data from a TCP/IP port. lParam points to a buffer where
  499. //  the data should be written: if wParam is non-zero, then it is
  500. //  whichever is the lesser of the size of the buffer, or the maximum
  501. //  number of bytes to read. If wParam is zero, then the buffer must
  502. //  be 1024 bytes long and the routine will wait until any data appears
  503. //  on the port then return it, up to 1024 bytes in length. This latter
  504. //  application is useful when dealing with protocols where you don't
  505. //  necessarily know how much data you are going to receive in advance.
  506. //  ** PARAMETERS: wParam = 0, or bufsize/maxdata; lParam = buffer address
  507. //  ** RETURNS:    The actual number of bytes read; < 0 indicates an
  508. //                 error; 0 indicates either socket closed or timeout.
  509.  
  510. #define WM_F_TCPWRITE            (WM_F_FORMBASE + 60)
  511. //  Write raw data to a TCP/IP port. lParam points to the data to write,
  512. //  and wParam points to the length of the data. The data is written
  513. //  without any modification. This routine never blocks, and enters an
  514. //  internal message processing loop while waiting for the data to clear.
  515. //  ** PARAMETERS: wParam = length of data; lParam = pointer to data
  516. //  ** RETURNS:    -1 on hard error; 0 on timeout; >0 on success (the
  517. //                   number of bytes actually written).
  518.  
  519. #define WM_F_TCPTIMEOUT          (WM_F_FORMBASE + 67)
  520. //  Get or set the WinPMail global TCP/IP timeout value. If wParam is
  521. //  0, lParam is ignored, and the current timeout is returned by the
  522. //  message (expressed as a number of seconds). If wParam is non-zero,
  523. //  lParam is presumed to contain a new value (expressed in seconds)
  524. //  which will be applied to subsequently-opened sockets. To set the
  525. //  timeout for a socket, you should make this call immediately before
  526. //  opening the connection, and should reset the original value once
  527. //  the socket has been successfully opened. Note that you cannot
  528. //  change the timeout value for a socket once it has been opened -
  529. //  it inherits the global value in force at that moment and retains
  530. //  it until closed.
  531. //  ** PARAMETERS:  wParam = 0 to get, 1 to set; lParam = new seconds value
  532. //  ** RETURNS:     The old value in seconds of the global timeout value.
  533.  
  534. #define WM_F_TCPSET              (WM_F_FORMBASE + 70)
  535. //  (** WinPMail v2.11 and later only **)
  536. //  Set the master POPDEF record maintained by Pegasus Mail (see above
  537. //  for the POPDEF data structure). Pegasus Mail uses this record to
  538. //  initiate SMTP and POP3 transactions for the user, and presents the
  539. //  values from this record when the "Network configuration" dialog is
  540. //  opened. If wParam is non-zero, then the structure you pass will be
  541. //  marked as "dirty" which will force WinPMail to save it immediately,
  542. //  replacing the user's existing TCP/IP preferences in PMAIL.INI. You
  543. //  should exercise caution using this message - it's really provided
  544. //  only for extensions that create default settings for users. The
  545. //  POPDEF you supply is copied by WinPMail - you do not have to keep
  546. //  it allocated after calling this function.
  547. //
  548. //  SETTING TRANSPORT OPTIONS: many of the settings to do with the way
  549. //  WinPMail loads and interacts with WINSOCK.DLL are held in a separate
  550. //  field within the user's preferences. You can access this field, which
  551. //  is a single unsigned char, using the W_PRO_POPOPTS index to the
  552. //  WM_GETPREF and WM_SETPREF messages. The character is a bitmap having
  553. //  the following possible values:
  554. //
  555. #ifndef WINPMAIL
  556. #define POP_OPEN_NEW          1     //  Check when opening new mail folder
  557. #define POP_IMMEDIATE_SEND    2     //  Send at once (don't queue)
  558. #define POP_PREFER            4     //  Prefer over Mercury for Internet mail
  559. #define POP_COUNT_ONLY        8     //  Message count only on idle polls
  560. #define POP_MINIMIZED_CHECKS  16    //  Allow checks when minimized
  561. #define POP_ALWAYS_USE        32    //  Use for all outgoing mail
  562. #define POP_DEMAND_LOAD       64    //  Load WINSOCK.DLL on demand
  563. #define SMTP_IDLE_SEND        128   //  Send queue during idle polls
  564. #endif
  565. //
  566. //  ** SEE ALSO:    WM_F_GETPREF and WM_F_SETPREF using W_PRO_POPOPTS index
  567. //  ** PARAMETERS:  wParam = 0/1 (see above); lParam = pointer to POPDEF
  568. //  ** RETURNS:     0 on failure, 1 on success.
  569.  
  570. #define WM_F_TCPGET              (WM_F_FORMBASE + 71)
  571. //  (** WinPMail v2.11 and later only **)
  572. //  Get the master POPDEF record maintained by Pegasus Mail (see above
  573. //  for the POPDEF data structure). Pegasus Mail uses this record to
  574. //  initiate SMTP and POP3 transactions for the user, and presents the
  575. //  values from this record when the "Network configuration" dialog is
  576. //  opened. See above under WM_F_TCPSET for more information on other
  577. //  aspects of controlling this configuration information.
  578. //  ** SEE ALSO:    WM_F_GETPREF and WM_F_SETPREF using W_PRO_POPOPTS index
  579. //  ** PARAMETERS:  wParam = unused; lParam = pointer to POPDEF
  580. //  ** RETURNS:     0 on failure, 1 on success.
  581.  
  582.  
  583. //
  584. // +--------------------------------------------------------------------+
  585. // |  Section 4:                                                        |
  586. // |  Calls available only to READER extensions                         |
  587. // +--------------------------------------------------------------------+
  588. //
  589.  
  590. #define WM_F_OPENMESSAGE         (WM_F_FORMBASE + 42)
  591. //  A reader extension can call this to open the original message
  592. //  passed to it at startup, or in response to a WM_FM_DROPPED message
  593. //  to access the dropped message.
  594. //  ** PARAMETERS: wParam = unused; lParam = unused
  595. //  ** RETURNS:    1 if successfully opened; 0 on failure.
  596.  
  597. #define WM_F_READLINE            (WM_F_FORMBASE + 43)
  598. //  Read a line from the original message. The message must have been
  599. //  opened successfully by calling WM_F_OPENMESSAGE before calling this
  600. //  routine.
  601. //  ** PARAMETERS: wParam = maximum length to read; lParam = pointer to buffer
  602. //  ** RETURNS:    1 if data was read, 0 on failure (usually EOF).
  603.  
  604. #define WM_F_CLOSEMESSAGE        (WM_F_FORMBASE + 44)
  605. //  Close a message file opened with WM_F_OPENMESSAGE. You MUST call
  606. //  this function when you have finished accessing the message.
  607. //  ** PARAMETERS: wParam = unused; lParam = unused.
  608. //  ** RETURNS:    Nothing.
  609.  
  610. #define WM_F_GETFLAGS            (WM_F_FORMBASE + 45)
  611. //  Get the flag longword for the message. The message does NOT have to
  612. //  be open in order for this call to succeed.
  613. //  ** PARAMETERS: wParam = unused; lParam = unused.
  614. //  ** RETURNS:    Flag longword (32 bits)
  615.  
  616. #define WM_F_SETFLAGS            (WM_F_FORMBASE + 46)
  617. //  Set the flag longword for the message. The message does NOT have
  618. //  to be open in order for this call to succeed. Note; this function
  619. //  is only provided to allow you to alter the "has been read", "replied",
  620. //  "forwarded" and "is annotated" flags. Changing or setting any other
  621. //  bit in the flag longword may have unexpected consequences and should
  622. //  only be done if you're absolutely sure of what you're doing.
  623. //  ** PARAMETERS: wParam = unused; lParam = Flag longword.
  624. //  ** RETURNS:    Nothing
  625.  
  626. //  The flag longword is a 32-bit bitmap which can consist of the
  627. //  following values:
  628. #ifndef WINPMAIL
  629. #define FILE_MAILED     1           // Message has local-style PMF attachments
  630. #define UUENCODED       2           // "   "   "   uuencoded attachments
  631. #define FILE_ATTACHED   0x800003L   // Use this as an attachment mask.
  632. #define ENCRYPTED       4           // Message is encrypted.
  633. #define EXPIRED         16          // Message is past its expiry date
  634. #define HAS_BEEN_READ   128         // The reader has opened the message
  635. #define CONFIRMATION    8192        // Sender wants confirmation of reading
  636. #define COPYSELF       0x20000L     // Message is a copy to self
  637. #define DELETED        0x40000L     // Message has been deleted.
  638. #define MIME           0x80000L     // Message is a MIME transmission
  639. #define REPLIED       0x100000L     // Message has been replied to.
  640. #define FORWARDED     0x200000L     // Message has been forwarded.
  641. #define URGENT        0x400000L     // Message is urgent/high priority.
  642. #define BINHEX        0x800000L     // Message contains BinHex-encoded data
  643. #define IS_MHS       0x1000000L     // Message originates from MHS
  644. #define IS_SMTP      0x2000000L     // Message originates from SMTP
  645. #define IS_ANNOTATED 0x4000000L     // The message has an annotation
  646. #define ENCLOSURE    0x8000000L     // The message has enclosures
  647. #endif
  648.  
  649. #define WM_F_ATTACHMENTINFO      (WM_F_FORMBASE + 47)
  650. //  Get details about an attachment from a message. wParam should
  651. //  indicate the index to the attachment for which data is required 
  652. //  (numbering from 0 as the first attachment) or -1 if you only want
  653. //  it to return a count of the number of attachments. lParam should
  654. //  point to an ATTACHMENT structure as defined in the WM_F_ATTACH
  655. //  message. You should generally only call this routine if the flag
  656. //  longword for the message indicates that attachments are present,
  657. //  although this routine does a much more thorough examination of the
  658. //  message for enclosures than the standard message parser and may
  659. //  pick up some which it misses.
  660. //  ** PARAMETERS: wParam = index or -1; lParam = pointer to ATTACHMENT
  661. //  ** RETURNS:    Number of attachments to message, or -1 on error
  662. //  ** Note:       This call cannot be used to handle components of
  663. //                 multipart MIME messages, since they are not necessarily
  664. //                 attachments. Pegasus Mail's own multipart browser is
  665. //                 capable of loading reader extensions for individual
  666. //                 components, but if you want to write your own multipart
  667. //                 browser to replace the built-in browser, you will have
  668. //                 handle the MIME sub-parsing yourself.
  669.  
  670. #define WM_F_EXTRACTATTACHMENT   (WM_F_FORMBASE + 48)
  671. //  Extract an attachment from a message into a specified file. wParam
  672. //  should indicate the index to the attachment required. lParam should
  673. //  point to a filename string; if lParam is NULL or if the first char
  674. //  in the filename string is an ASCII NUL (0), then WinPMail will
  675. //  prompt the user for a filename, and if lParam is non-NULL, will
  676. //  return it in lParam (allocate at least 128 characters). All decoding
  677. //  of the message is performed automatically, including MIME translations.
  678. //  ** PARAMETERS: wParam = index to attachment; lParam = see above
  679. //  ** RETURNS:    1 on success, < 1 on failure
  680.  
  681. #define WM_F_NEXTMESSAGE         (WM_F_FORMBASE + 68)
  682. //  Open the next message in the folder from which the current message
  683. //  was loaded. If successful, this message will result in the current
  684. //  window being closed normally.
  685. //  ** PARAMETERS: wParam = unused; lParam = unused
  686. //  ** RETURNS:    HWND of new message on success; 0 on failure
  687.  
  688. #define WM_F_PREVMESSAGE         (WM_F_FORMBASE + 69)
  689. //  Open the message before the current message in the folder from which
  690. //  the current message was loaded. If successful, this message will
  691. //  result in the current window being closed normally.
  692. //  ** PARAMETERS: wParam = unused; lParam = unused
  693. //  ** RETURNS:    HWND of new message on success; 0 on failure
  694.  
  695.  
  696. //
  697. // +--------------------------------------------------------------------+
  698. // |  Section 5:                                                        |
  699. // |  Logging messages                                                  |
  700. // +--------------------------------------------------------------------+
  701. //
  702. // Extensions can indicate an interest in logging events by setting the
  703. // WPM_LOGGING bit in the flags field of their form fact file. An extension
  704. // which has set the logging bit will receive messages from WinPMail about
  705. // a number of events which can occur in a user session, including mail
  706. // being sent, files being created and deleted, and so on.
  707. //
  708. // Logging extensions can also inhibit certain events from happening by
  709. // returning WPM_PROHIBIT instead of 0; note that if an extension prohibits
  710. // an action, it is up to the extension to indicate an error message or
  711. // warning explaining to the user why it has done so (if appropriate) -
  712. // WinPMail will not do so.
  713. //
  714. // There are no limitations on what a logging extension can do, although
  715. // in almost every case they will set the WPM_STARTUP bit to load at
  716. // runtime. Logging extensions may generate mail messages at any time.
  717. //
  718.  
  719. #define WM_FM_SENDMAIL           (WM_FM_FORMBASE + 8)
  720. //  WinPMail generates this message when the user sends a mail message,
  721. //  before any actual processing is done on the message itself. When a
  722. //  logging extension receives this message, it can call 
  723. //  WM_F_GETMESSAGEFIELD as shown below to retrieve message fields 
  724. //  until the time it returns. A logging extension can prohibit sending a
  725. //  message by returning WPM_PROHIBIT when it receives this message.
  726.  
  727. #define WM_FM_LOGEVENT           (WM_FM_FORMBASE + 9)
  728. //  WinPMail generates this message to cover a variety of system
  729. //  events. In most cases, returning WPM_PROHIBIT will prevent the
  730. //  action from occurring.
  731. //  ** PARAMETERS: wParam = event type; lParam = string descriptor
  732. //    wParam can have the following values:
  733. //                      wParam      lParam                            Prohibit?
  734. #define WLOG_OPEN_FILE    1     //  Filename of book to be opened         Y
  735. #define WLOG_DEL_FILE     2     //  "   "   "   "   "   be deleted        Y
  736. #define WLOG_NEW_FILE     3     //  Unused                                Y
  737. #define WLOG_REN_FILE     4     //  Old filename of book to be renamed    Y
  738. #define WLOG_OPEN_FOLDER  5     //  Path to folder to be opened           Y
  739. #define WLOG_DEL_FOLDER   6     //  "   "   "   "   "   be deleted        Y
  740. #define WLOG_NEW_FOLDER   7     //  Unused                                Y
  741. #define WLOG_REN_FOLDER   8     //  Old filename of folder to be renamed  Y
  742. #define WLOG_EDIT_FILE    9     //  Filename of dlist to be edited        Y
  743. #define WLOG_ACTIVATE     10    //  1=activating, 0=minimizing            Y
  744. //  WLOG_NEWMESSAGE is sent before the window is actually
  745. //  created and displayed; WLOG_NEWMESSAGE1 is sent after the
  746. //  window has been completely created.
  747. #define WLOG_NEWMESSAGE   11    //  Unused                                Y
  748. #define WLOG_NEWMESSAGE2  12    //  HWND of new message                   N
  749. //  WLOG_ENTERPREFS is called before entering any of the preferences
  750. //  dialogs in WinPMail, using one of the following values in lParam
  751. enum
  752.    {
  753.    WPREF_GENERAL, WPREF_ADVANCED, WPREF_SMF, WPREF_HOMEBOX,
  754.    WPREF_EXTENDED, WPREF_SIGS, WPREF_BPANEL, WPREF_NETCONFIG
  755.    };
  756. #define WLOG_ENTERPREFS    13   //  Code from list above                  Y
  757. //  WLOG_GETMAIL is sent prior to downloading mail via POP3
  758. #define WLOG_GETMAIL       14   //  Unused                                Y
  759. //  WLOG_SMTPSEND is sent before opening an outgoing SMTP connection
  760. #define WLOG_SMTPSEND      15   //  Unused                                Y
  761. //  WLOG_NEWEXTENSION is sent before an extension is loaded
  762. #define WLOG_NEWEXTENSION  16   //  Path to extension file                Y
  763. #define WLOG_ERROR         17   //  Integer - ID of error message         Y
  764. #define WLOG_WARNING       18   //  Integer - ID of warning message       Y
  765. //  WLOG_LOADEXTENSION is sent AFTER an extension has been loaded
  766. #define WLOG_LOADEXTENSION 19   //  HWND - window containing new form     N
  767. #define WLOG_OPENNEWMAIL   20   //  Unused
  768. #define WLOG_PARSENEW      21   //  Path to new message file              Y
  769. //
  770. //  Detecting when menus are loaded: WLOG_LOADMENU is generated when an
  771. //  MDI window in WinPMail loads a menu. The completed menu is passed to
  772. //  the extension in an LMENU structure, and while the extension cannot
  773. //  suppress the loading of the menu, it can modify the menu. Note that
  774. //  each menu is a complete copy of the entire menu system, including
  775. //  File, Edit, Addresses, and Window submenus as well as the specific
  776. //  menu for the subwindow itself.
  777. //
  778. typedef struct
  779.    {
  780.    HMENU hMenu;
  781.    int menu_id;
  782.    } LMENU;
  783. //  "menu_id" can have the following values:
  784. //
  785. #ifndef WINPMAIL
  786. enum
  787.    {
  788.    MN_FRAME = 1,        //  Pegasus Mail's frame (main window) menu
  789.    MN_EDMAIL,           //  Message editor menu ("Message")
  790.    MN_READER,           //  Message reader menu ("Reader")
  791.    MN_BROWSE,           //  Folder browser menu ("Folder")
  792.    MN_DLIST,            //  DList editor menu (no specific menu entry)
  793.    MN_ADDRBOOK,         //  Addressbook menu ("Addressbook")
  794.    MN_FOLMAN,           //  Floating Folder Manager menu ("Folders")
  795.    MN_FORMS,            //  Extensions Manager menu (no specific entry)
  796.    MN_NB,               //  Noticeboards menu.
  797.    MN_DLM               //  Distribution List Manager menu ("Lists")
  798.    };
  799. #endif
  800. //
  801. #define WLOG_LOADMENU      22   //  Pointer to LMENU structure (above)    N
  802. #define WLOG_SENDERROR     23   //  Locus of delivery failure             N
  803.  
  804. #define WLOG_APPLYRULE     24   //  Pointer to RULE_EVENT structure       Y
  805. //  Indicates that a new mail filtering rule has been triggered
  806. //  for application to a message. lParam points to the following
  807. //  structure:
  808. typedef struct
  809.    {
  810.    int action;
  811.    char *param;
  812.    void *imessage;
  813.    int fol_id;
  814.    } RULE_EVENT;
  815.  
  816. #define WLOG_NEWDIALOG     25   //  Pointer to CREATION_EVENT struct      N
  817. //  ** Note: Requires Extension Manager v1.02 or later
  818. //  Detecting when dialogs are created: WinPMail sends WLOG_NEWDIALOG
  819. //  messages to logging extensions when particular dialog windows are
  820. //  created, but before they are displayed. You cannot prohibit the
  821. //  creation of a dialog, but there is nothing to stop you from
  822. //  superclassing it (in fact, this is the expected use of this
  823. //  logging message). lParam points to the following structure:
  824. typedef struct
  825.    {
  826.    HWND hDialog;           //  The dialog's window handle
  827.    int selector;           //  Type of dialog - see NDLG_* values below
  828.    void *data;             //  Window-specific data
  829.    } CREATION_EVENT;
  830. //  "selector" can have the following values:
  831. enum
  832.    {
  833.    NDLG_MESSAGE_EDITOR = 1,  //  Message editor "editor" dialog
  834.    NDLG_MESSAGE_ATTACH,      //  Message editor "attach" dialog
  835.    NDLG_MESSAGE_SPECIAL,     //  Message editor "special" dialog
  836.    NDLG_ENCRYPT,             //  "Encrypt message" dialog (modal)
  837.    NDLG_NORMAL_READER,       //  Standard message reader dialog
  838.    NDLG_MMP_READER,          //  MIME Multipart reader dialog
  839.    NDLG_MMD_READER,          //  MIME Multipart digest dialog
  840.    NDLG_NB_READER,           //  A noticeboard reader dialog
  841.    NDLG_BINARY_READER,       //  Binary data reader dialog
  842.    NDLG_FOLDER,              //  Standard folder window, data=filename
  843.    NDLG_FOLMAN,              //  Folder Manager window
  844.    NDLG_ADDRESSBOOK,         //  Addressbook window, data=filename
  845.    NDLG_LOCALUSERS,          //  Local user list
  846.    NDLG_LOGGEDUSERS,         //  Logged-in user list
  847.    NDLG_NETCONFIG,           //  Network Configuration dialog
  848.    NDLG_GPREFS,              //  General preferences
  849.    NDLG_APREFS,              //  Advanced settings
  850.    NDLG_HOMEBOX,             //  Home mailbox location preference
  851.    NDLG_VIEWER,              //  Attachment viewer preferences
  852.    NDLG_EPREFS,              //  Extended features dialog
  853.    NDLG_MPREFS               //  MHS preferences
  854.    };
  855.  
  856. #define WLOG_SAVEFILE      26   //  Pointer to filename                   Y
  857. //  ** Note: Requires Extension Manager v1.02 or later
  858. //  Sent whenever Pegasus Mail saves a file to disk, except when
  859. //  saving plain textual data. This message usually only occurs
  860. //  when WinPMail saves an attachment to disk and is intended to
  861. //  allow the invocation of virus-scanning modules and so on. Returning
  862. //  WPM_PROHIBIT to this message has a slightly different meaning from
  863. //  other places in the program - it means that you have deleted the
  864. //  file for some reason. You must ONLY return WPM_PROHIBIT if you have
  865. //  actually deleted the file.
  866. //  ** TECHNICAL NOTE: Because of the doubly-indirect way BinHex
  867. //     encoding is handled within WinPMail, you may occasionally get
  868. //     this message twice for the same file. Accordingly, you should
  869. //     always check for the existence of the file before doing anything
  870. //     else with it. If the file does NOT exist, you should return
  871. //     WPM_PROHIBIT, as if you had deleted it.
  872.  
  873.  
  874. #define WM_F_GETMESSAGEFIELD     (WM_F_FORMBASE + 50)
  875. //  Retrieve a field from a message. This message can only be sent
  876. //  after a logging extension receives a WM_FM_SENDMAIL message but
  877. //  before it returns from processing it.
  878. //  ** PARAMETERS: wParam = field of interest
  879. //  ** RETURNS:    pointer to data in every case.
  880. //
  881. //  wParam can be set to the following values:
  882. //      wParam value:          type      pointer to
  883. #define WMSG_TO       1    //  string    raw to: data
  884. #define WMSG_SUBJECT  2    //  string    subject: field
  885. #define WMSG_CC       3    //  string    cc: field
  886. #define WMSG_BCC      4    //  string    bcc: field
  887. #define WMSG_REPLYTO  5    //  string    reply-to: field
  888. #define WMSG_DATA     6    //  string    message, NULL if file.
  889. #define WMSG_FILE     7    //  string    filename, NULL if data
  890. #define WMSG_ENCRYPT  8    //  char      NZ if encrypted, Z if not
  891. #define WMSG_COPYSELF 9    //  char      NZ if copying to self
  892. #define WMSG_READING  10   //  char      NZ if reading confirm required
  893. #define WMSG_DELIVERY 11   //  char      NZ if delivery confirm required
  894. #define WMSG_URGENT   12   //  char      NZ if urgent
  895. #define WMSG_NOSIG    13   //  char      NZ if no signature to be attached
  896. #define WMSG_EXPIRES  14   //  byte [7]  expiration, NetWare date format
  897. #define WMSG_KEY      15   //  string    encryption key
  898. //
  899. //  Note that the returned value is ALWAYS a pointer, which allows a
  900. //  logging extension to change message field values before they are
  901. //  sent. Extensions are discouraged from modifying fields casually -
  902. //  fields should only be changed when you are sure of what you are
  903. //  doing.
  904.  
  905.  
  906. //
  907. // +--------------------------------------------------------------------+
  908. // |  Section 6:                                                        |
  909. // |  File system, message store and informational services             |
  910. // +--------------------------------------------------------------------+
  911. //
  912. // Extensions can access the user's message store and also have access
  913. // to a great deal of the internal system information WinPMail maintains.
  914. //
  915.  
  916. #define WM_F_GETVERSION          (WM_F_FORMBASE + 75)
  917. //  Get the version number of the running copy of WinPMail. The version
  918. //  number is returned as an integer with the Major version number in the
  919. //  high byte and the minor version number in the low byte.
  920. //  ** PARAMETERS: wParam = reserved, must be 0; lParam = reserved, must be 0
  921. //  ** RETURNS:    Version number.
  922. //  ** VERSION:    Requires version 1.02 or later of the Extension Manager
  923.  
  924. #define WM_F_GETNEWMAILBOX       (WM_F_FORMBASE + 21)
  925. //  Get the full path to the user's new mail folder.
  926. //  lParam points to a buffer into which the path should be copied,
  927. //  and wParam is the maximum length of the string to copy, including
  928. //  the terminating nul. You should allocate at least 128 characters.
  929. //  The string returned is a full path normalized to "\" separators
  930. //  and does not have a trailing "\" character.
  931. //  ** Note: do NOT assume that this is a DOS path: it may just as
  932. //  well be supplied in UNC or NetWare formats depending on the system.
  933. //  ** PARAMETERS: wParam = max length; lParam = pointer to buffer
  934. //  ** RETURNS:    Nothing
  935.  
  936. #define WM_F_GETHOMEBOX          (WM_F_FORMBASE + 22)
  937. //  Get the full path to the user's home mailbox directory.
  938. //  lParam points to a buffer into which the path should be copied,
  939. //  and wParam is the maximum length of the string to copy, including
  940. //  the terminating nul. You should allocate at least 128 characters.
  941. //  The string returned is a full path normalized to "\" separators
  942. //  and does not have a trailing "\" character.
  943. //  ** PARAMETERS: wParam = max length; lParam = pointer to buffer
  944. //  ** RETURNS:    Nothing
  945. //  ** Note: do NOT assume that this is a DOS path: it may just as
  946. //  well be supplied in UNC or NetWare formats depending on the system.
  947.  
  948. #define WM_F_GETTEMPDIR          (WM_F_FORMBASE + 23)
  949. //  Get the full path to the recommended temporary files directory.
  950. //  lParam points to a buffer into which the path should be copied,
  951. //  and wParam is the maximum length of the string to copy, including
  952. //  the terminating nul. You should allocate at least 128 characters.
  953. //  The string returned is a full path normalized to "\" separators
  954. //  and does not have a trailing "\" character.
  955. //  ** PARAMETERS: wParam = max length; lParam = pointer to buffer
  956. //  ** RETURNS:    Nothing
  957.  
  958. #define WM_F_GETBASEDIR          (WM_F_FORMBASE + 65)
  959. //  Get the full path to the directory from which WINPMAIL.EXE was
  960. //  run. lParam points to a buffer into which the path should be
  961. //  copied and wParam is the maximum length of the string to copy,
  962. //  including the terminating nul. You should allocate at least 128
  963. //  characters. The string returned is a full path in DOS format
  964. //  and does not have a trailing "\" character.
  965.  
  966. #define WM_F_BROWSEFILE          (WM_F_FORMBASE + 72)
  967. //  Open the Pegasus Mail "Enter filename" browser and allow the user
  968. //  to select a file. lParam should point to a buffer 128 characters
  969. //  long, where the resulting filename will be written. If wParam is
  970. //  zero, WinPMail will issue a warning if the user attempts to
  971. //  select a file that already exists. On entry, lParam can contain
  972. //  a path and a wildcard specification, both of which will be used
  973. //  by the browser - so for example, passing in "C:\WINWORD\*.DOC"
  974. //  will commence browsing in C:\WINWORD and will default to the
  975. //  document filter "*.DOC".
  976. //  ** PARAMETERS: wParam = 0 if new file; lParam = pointer to char [128]
  977. //  ** RETURNS:    Non-zero if a file was successfully selected.
  978. //  ** VERSION:    Requires version 1.02 or later of the Extension Manager
  979.  
  980. #define WM_F_TEMPFILE            (WM_F_FORMBASE + 24)
  981. //  Get the fully-qualified path name of a temporary file which
  982. //  is guaranteed not to exist, and to be writable. wParam contains
  983. //  the maximum length allocated for the filename including the
  984. //  terminating Nul, while lParam points to the location where the
  985. //  filename should be written.
  986. //  ** PARAMETERS: wParam = max length; lParam = pointer to buffer
  987. //  ** RETURNS:    Nothing
  988.  
  989. #define WM_F_NEWMAIL             (WM_F_FORMBASE + 28)
  990. //  Get the number of new mail messages currently in the user's
  991. //  new mail box. If wParam is 0, WinPMail returns the value from the
  992. //  last periodic scan it made; if wParam is non-zero, WinPMail is
  993. //  forced to rescan the new mail box immediately - depending on
  994. //  the number of messages already in the new mail box, this may
  995. //  result in a considerable impact on system performance. Returns
  996. //  the number of messages.
  997. //  ** PARAMETERS: wParam = (see above); lParam = unused
  998. //  ** RETURNS:    Total number of new messages in mailbox
  999.  
  1000. #define WM_F_SELECTOR            (WM_F_FORMBASE + 39)
  1001. //  Prompt the user to select a WinPMail file. The standard WinPMail
  1002. //  selector dialog is opened and control is not returned until the
  1003. //  user either selects an item or cancels it.
  1004. //  ** PARAMETERS: 
  1005. //     wParam can have the following values:
  1006. //        0 - select a folder
  1007. //        1 - select an address book
  1008. //        2 - select a distribution list
  1009. //        3 - select a message draft
  1010. //     lParam = points to a char buffer at least 128 characters long
  1011. //        - the buffer is filled with the full path name to the selected
  1012. //          file. For address books, the .PMR file is returned. For
  1013. //          folders, the .PMM file is returned.
  1014. //  ** RETURNS: 1 if the user selected an item, 0 for no selection.
  1015.  
  1016. #define WM_F_OPENFILE            (WM_F_FORMBASE + 66)
  1017. //  Open one of the standard Pegasus Mail file types. lParam must point
  1018. //  to the full path to the file (as returned by WM_F_SELECTOR), and
  1019. //  wParam must be set to:
  1020. //        0 - File is a mail folder
  1021. //        1 - File is an address book
  1022. //        2 - File is a distribution list
  1023. //        3 - File is a message draft
  1024. //        4 - File is a message queued for delivery
  1025. //      255 - No file - simply start a new message
  1026. //  Note that for Folders you must pass the path to the folder's PMM
  1027. //  file, and for Addressbooks to the book's .PMR file. The extensions
  1028. //  for the various types of files are:
  1029. //     Folders            - .PMM
  1030. //     Addressbooks       - .PMR
  1031. //     Distribution lists - .PML
  1032. //     Message drafts     - .PMO
  1033. //     Queued mail        - .PMW
  1034. //  ** PARAMETERS: wParam (see above); lParam = file to open.
  1035. //  ** RETURNS:    hWnd of newly-opened MDI window, NULL on failure.
  1036.  
  1037. #define WM_F_GETPREF             (WM_F_FORMBASE + 40)
  1038. #define WM_F_SETPREF             (WM_F_FORMBASE + 41)
  1039. //  Preferences services. Get or set the value of an entry in the
  1040. //  user's preferences (PMAIL.INI) file. Examine the file WPMPREFS.H
  1041. //  for documentation on the possible values you can pass in these
  1042. //  calls.
  1043. //  ** PARAMETERS:
  1044. //     - WM_F_SETPREF: wParam = item to set; lParam = value
  1045. //     - WM_F_GETPREF: wParam = item to get; lParam = buffer pointer
  1046. //  ** RETURNS:
  1047. //     - WM_F_SETPREF: Nothing
  1048. //     - WM_F_GETPREF: Value (for scalar types).
  1049.  
  1050. #define WM_F_GETUSERNAME         (WM_F_FORMBASE + 58)
  1051. //  Get the name of the user at the current workstation. wParam can
  1052. //  have the following values:
  1053. //    0: return the basic username (login name under NetWare)
  1054. //    1: return the user's name as a full Internet address
  1055. //    2: return the user's name as an MHS address
  1056. //  lParam should point to a buffer at least 256 characters in length.
  1057. //  ** PARAMETERS: wParam = (see above); lParam = pointer to buffer
  1058. //  ** RETURNS:    1 on success; 0 if the address form is unavailable.
  1059.  
  1060.  
  1061. //
  1062. // +--------------------------------------------------------------------+
  1063. // |  Section 7:                                                        |
  1064. // |  Miscellaneous services                                            |
  1065. // +--------------------------------------------------------------------+
  1066. //
  1067.  
  1068. #define WM_F_GETDATETIME         (WM_F_FORMBASE + 25)
  1069. //  Return the current date and time in NetWare format - ie, an
  1070. //  array of seven bytes arranged as follows:
  1071. //
  1072. //     Byte 0  - Year modulus 100 (if less than 80 assume 20xx)
  1073. //     Byte 1  - Month - 1 (ie, January == 0)
  1074. //     Byte 2  - Day (1 .. 31)
  1075. //     Byte 3  - Hour (0 - 24)
  1076. //     Byte 4  - Minute (0 - 59)
  1077. //     Byte 5  - Second (0 - 60)
  1078. //     Byte 6  - Day of week (Sunday == 0)
  1079. //
  1080. //  The function returns a correctly-formatted value whether or not
  1081. //  you are actually attached to a NetWare system, and deals correctly
  1082. //  with shell problems under Windows Standard mode which can result
  1083. //  in NetWare returning garbage times. Where possible, this function
  1084. //  gets the time from the file server instead of from the local
  1085. //  workstation.
  1086. //  ** PARAMETERS: wParam = unused; lParam = pointer to 7-byte buffer area
  1087. //  ** RETURNS:    Nothing
  1088.  
  1089. #define WM_F_GETRFC822DATETIME   (WM_F_FORMBASE + 26)
  1090. //  Return a date and time string in legal RFC822 format. You can
  1091. //  either set lParam to point to a 7-byte structure as described in
  1092. //  WM_F_GETDATETIME above, or else you can set lParam to 0 to get
  1093. //  a legal RFC822 representation of the current time. The return
  1094. //  from this message is a pointer to a static buffer in memory
  1095. //  containing the formatted string. You must NEVER directly alter
  1096. //  this buffer or you may crash WinPMail. The buffer is overwritten
  1097. //  on each call, and may be overwritten indirectly by other internal
  1098. //  WinPMail routines, so if you do not intend to use this string
  1099. //  immediately, you would be well advised to copy it to a local buffer.
  1100. //  ** PARAMETERS: wParam = unused; lParam = (optional) 7-byte date structure
  1101. //  ** RETURNS:    Read-only far pointer to character array containing date.
  1102.  
  1103. #define WM_F_PARSEADDRESS        (WM_F_FORMBASE + 27)
  1104. //  Reduce an e-mail address to its minimum form, by removing any
  1105. //  Ctext or Qtext components - so, the address
  1106. //      "David Harris" <david@pmail.gen.nz> (Pegasus Mail Author)
  1107. //  would be reduced to
  1108. //       david@pmail.gen.nz
  1109. //  lParam should point to the raw address, which is overwritten with
  1110. //  the reduced form. The returned value is guaranteed never to be
  1111. //  longer than the value passed in.
  1112. //  ** PARAMETERS: wParam = unused; lParam = raw address data
  1113. //  ** RETURNS:    -1 on invalid address (unbalanced '()' or '<>' pairs)
  1114. //  ** Note: this function works equally well for both RFC822 and
  1115. //  MHS addresses, but you should be aware that comments in '()' pairs
  1116. //  are sometimes significant to some MHS gateways.
  1117.  
  1118. #define WM_F_MALLOC              (WM_F_FORMBASE + 30)
  1119. //  Allocate memory in WinPMail's heap. This call is specialised and
  1120. //  is generally not needed. wParam contains the number of bytes to
  1121. //  allocate; the return value is NULL on failure, or a pointer on
  1122. //  success. Note that memory obtained this way must ONLY be freed
  1123. //  using the WM_F_FREE message.
  1124. //  ** PARAMETERS: wParam = bytes to allocate; lParam = unused
  1125. //  ** RETURNS:    Pointer, or NULL on failure
  1126.  
  1127. #define WM_F_FREE                (WM_F_FORMBASE + 31)
  1128. //  Free a block of memory obtained using WM_F_MALLOC
  1129. //  ** PARAMETERS: wParam = unused; lParam = pointer returned by WM_F_MALLOC
  1130. //  ** RETURNS:    Nothing
  1131.  
  1132. #define WM_F_GETTEXT             (WM_F_FORMBASE + 32)
  1133. //  A handy function to retrieve the text from a standard Windows
  1134. //  edit control in a format ready to be dumped to a file or passed
  1135. //  to WinPMail for delivery; pass the ID of the control in the
  1136. //  current dialog in wParam and WinPMail will return the text from
  1137. //  that control, properly formatted, with all carriage returns
  1138. //  stripped (ie, as a C string). The pointer returned is allocated
  1139. //  using the WM_F_MALLOC message and must be freed using WM_F_FREE.
  1140. //  ** PARAMETERS: wParam = edit control ID; lParam = unused
  1141. //  ** RETURNS:    Pointer to formatted textual data or NULL on failure
  1142.  
  1143. #define WM_F_SETDIALOG           (WM_F_FORMBASE + 33)
  1144. //  Change the active dialog in the window. This function is needed
  1145. //  if your DLL can produce more than one dialog in the MDI child
  1146. //  window and can change between them (presumably in response to
  1147. //  user input, much like the WinPMail message editor dialog). When
  1148. //  the dialog active in the window changes and the window is in the
  1149. //  foreground, you should call this function to ensure that WinPMail
  1150. //  directs messages to the correct dialog. Pass the address of the
  1151. //  new dialog in lParam.
  1152. //  ** PARAMETERS: wParam = unused; lParam = HWND of new dialog
  1153. //  ** RETURNS:    Nothing
  1154.  
  1155. #define WM_F_SETSTATUS           (WM_F_FORMBASE + 51)
  1156. //  Set text on the statusline. Four text areas can be set on the
  1157. //  statusline:
  1158. //     0: The basic text area at the left-hand end of the bar
  1159. //     1: The text in the username/server panel of the bar
  1160. //     2: The text in the newmail panel of the bar
  1161. //     3: A double-size text area overlaid over 0 and 1
  1162. //  You can also reset the statusbar by setting wParam to 0 and
  1163. //  passing a pointer to a NULL string
  1164. //  ** PARAMETERS: wParam = panel to set; lParam = text to set
  1165. //  ** RETURNS:    Nothing.
  1166.  
  1167. #define WM_F_PASTEDATA           (WM_F_FORMBASE + 54)
  1168. //  Paste an arbitrary string of data into the last active control
  1169. //  (which will almost always be one of the addressing Edit fields).
  1170. //  Using this call allows you to duplicate the behaviour of the
  1171. //  WinPMail local user list or address books when the user clicks
  1172. //  the "paste" button. If wParam is non-zero, WinPMail will add a
  1173. //  newline (CRLF) to the data if the target control is capable of
  1174. //  supporting multiple lines; this is a handy way of allowing the
  1175. //  user to paste your data either into single address fields or into
  1176. //  distribution lists without you having to be worried about the
  1177. //  distinction. If wParam is zero, the data will be pasted as-is.
  1178. //  ** PARAMETERS: wParam = see above; lParam = (char *) text to paste
  1179. //  ** RETURNS:    0 if no pasting was possible, 1 on success.
  1180.  
  1181. #define WM_F_GETWINDOW           (WM_F_FORMBASE + 57)
  1182. //  Get a core WinPMail window. This function allows you to obtain
  1183. //  the HWND for either the WinPMail Frame window (the main application
  1184. //  window itself) or the MDI Client window maintained inside it. This
  1185. //  function is extremely specialised and is really only useful if you
  1186. //  are brave enough to want to enumerate the program's child windows
  1187. //  (possibly to send them all messages or to find all windows of a
  1188. //  particular type). You should avoid using this message if you can,
  1189. //  since it may impair the portability of your extension. WinPMail's
  1190. //  author offers no guarantee that windows will retain the same class
  1191. //  names or other information throughout the life of the program.
  1192. //  wParam can have the following values for this call:
  1193. //     0 - return the WinPMail main frame window
  1194. //     1 - return the WinPMail MDI client window
  1195. //     2 - return the currently active MDI child window
  1196. //     3 - return the dialog contained in the currently active MDI window
  1197. //     4 - return the toolbar window (note - ONLY if currently a toolbar)
  1198. //  ** PARAMETERS: wParam = see above; lParam = unused.
  1199. //  ** RETURNS:    The HWND for the specified window.
  1200.  
  1201. #define WM_F_GETMENU             (WM_F_FORMBASE + 63)
  1202. //  Get a core WinPMail menu. This function lets you retrieve any
  1203. //  of the menu handles associated with each type of WinPMail MDI
  1204. //  window. wParam should contain one of the MN_* selector values
  1205. //  defined for the WLOG_LOADMENU logging event (above). The return
  1206. //  value is the menu handle for that window, which may be NULL if
  1207. //  no instance of that type of window has been opened yet.
  1208. //  ** PARAMETERS: wParam = MN_* selector value; lParam = unused
  1209. //  ** RETURNS:    menu handle (may be NULL)
  1210.  
  1211. #define WM_F_LOADEXTENSION       (WM_F_FORMBASE + 64)
  1212. //  Load and execute a new extension. lParam must point to an instance
  1213. //  of the following parameter block:
  1214. typedef struct
  1215.    {
  1216.    char dll_path [128];
  1217.    int variant;
  1218.    char commandline [128];
  1219.    char title [64];
  1220.    unsigned int flags;
  1221.    } FORM_PARAM;
  1222. //
  1223. //  "dll_name" is the fully-qualified path to the DLL containing the
  1224. //     extension's executable code. It may contain valid command
  1225. //     substitutions (such as ~a for the Pegasus Mail base directory).
  1226. //  "variant" is 0 for a Composer extension, or 1 for a Reader extension.
  1227. //     Note that until advised in future, only Composer extensions can
  1228. //     be loaded with this call.
  1229. //  "commandline" is whatever parameters should be passed to the extension
  1230. //     at startup.
  1231. //  "title" is the title of the new extension's enclosing MDI window
  1232. //  "flags" is a bitmap comprised of the following values:
  1233. //     WPM_HIDDEN    4      Hide the parent MDI window on loading
  1234. //     WPM_LOGGING   8      Extension wants to receive logging events
  1235. //     WPM_ONEONLY   16     Only allow one running instance at any time
  1236. //
  1237. //  ** PARAMETERS: wParam = unused; lParam = pointer to FORM_PARAM
  1238. //  ** RETURNS:    HWND of new extension's MDI window or NULL on failure
  1239.  
  1240. #define WM_F_ADDBUTTON           (WM_F_FORMBASE + 73)
  1241. //  Add a button to the Pegasus Mail button panel. wParam is unused, and
  1242. //  lParam contains a pointer to the following structure:
  1243. typedef struct
  1244.    {
  1245.    char bitmap_file [128];
  1246.    char title_text [64];
  1247.    HWND owner_window;
  1248.    UINT wMsg;
  1249.    WPARAM wParam;
  1250.    LPARAM lParam;
  1251.    } BUTTONDEF;
  1252. //  "bitmap_file" contains the path to the Windows .BMP file to load and
  1253. //     use as the button's face. The bitmap should be 16 colours or more
  1254. //     and must be 22(h) x 20(v) pixels in size.
  1255. //  "title_text" contains the "fly-by" help that is presented on the status
  1256. //     line when the button is right-clicked.
  1257. //  "owner_window" is the HWND of the Window to which "wMsg" should be sent
  1258. //     when the button is triggered.
  1259. //  "wMsg", "wParam" and "lParam" are the remaining parameters of the
  1260. //     message sent to "owner_window" when the button is triggered. They
  1261. //     may can contain whatever values are appropriate.
  1262. //  Note that it is possible to use this function to create buttons on the
  1263. //  toolbar that trigger standard internal functions. To do this, use the
  1264. //  WM_F_GETWINDOW message to retrieve the handle of WinPMail's Frame
  1265. //  window then register a button that generates a WM_COMMAND message to
  1266. //  that window containing the proper ID and command values to trigger the
  1267. //  function.
  1268. //  The return from this message is 0 if unsuccessful (usually means there
  1269. //  are too many buttons already defined), or a "button handle" > 0 if
  1270. //  successful. The "button handle" may be passed via the WM_F_REMOVEBUTTON
  1271. //  message to remove the button.
  1272. //  ** PARAMETERS: wParam = unused; lParam = pointer to BUTTONDEF
  1273. //  ** RETURNS:    handle to button (see above)
  1274. //  ** VERSION:    Requires version 1.02 or later of the Extension Manager
  1275.  
  1276. #define WM_F_REMOVEBUTTON        (WM_F_FORMBASE + 74)
  1277. //  Remove a button added using WM_F_ADDBUTTON. wParam contains the button
  1278. //  handle returned by that message. The bitmap created for the button is
  1279. //  automatically destroyed. Note that it is explicitly legal for an
  1280. //  Extension to add a button then terminate without removing it - this is
  1281. //  the standard way of defining a button for a standard built-in feature.
  1282. //  ** PARAMETERS: wParam = button handle; lParam = unused
  1283. //  ** RETURNS:    None
  1284. //  ** VERSION:    Requires version 1.02 or later of the Extension Manager
  1285.  
  1286.