SMTP/POP3/IMAP Email Engine
Library for Delphi
Programmer's Manual
(SEE4D)
Version 5.2
April 15, 2010
This software is provided as-is.
There are no warranties, expressed or implied.
Copyright (C) 2010
All rights reserved
MarshallSoft Computing, Inc.
Post Office Box 4543
Huntsville AL 35815
Email: info@marshallsoft.com
Web: www.marshallsoft.com
MARSHALLSOFT is a registered trademark of MarshallSoft Computing.
1 Introduction
1.1 Features2 Library Overview
1.2 Documentation Set
1.3 Example Program
1.4 Installation
1.5 Uninstalling
1.6 Pricing
1.7 Updates
2.1 Dynamic Link Libraries3 Compiler Issues
2.2 Keycode
2.3 Win32 STDCALL and DECLSPEC
2.4 Error Display
2.5 Adding SEE4D to your Project
3.1 Delphi Versions4 Example Programs
3.2 SEE4D Wrapper
3.3 Delphi Personalities
3.4 Compiling Programs
4.1 Connectionless Example Programs5 Revision History
4.2 SMTP Example Programs
4.3 POP3/IMAP Example Programs
4.4 IMAP-Only Example Programs
The SMTP/POP3/IMAP Email Engine for Delphi (SEE4D) library is toolkit that allows software developers to quickly develop SMTP and POP3/IMAP email applications in Delphi and Delphi for .NET.
The SMTP/POP3/IMAP Email Engine (SEE) SDK is a component library of functions that uses the Windows API to provide direct and simple control of the SMTP (Simple Mail Transport Protocol), POP3 (Post Office 3), and IMAP 4 (Internet Message Access Protocol) protocols.
A straightforward interface allows sending and receiving email, including multiple MIME base64 and quoted-printable encoded attachments, over any TCP/IP network (such as the Internet). Knowledge of Winsock and TCP/IP is not needed.
The SMTP/POP3/IMAP Programmer's Manual for Delphi provides information needed to compile and run programs in a Delphi programming environment.
The SMTP/POP3/IMAP Email Engine for Delphi component library supports and has been tested with all 32-bit versions of Borland (CodeGear) Delphi 2 through 7, Delphi for .NET, and Delphi (2005-2010). SEE4D includes numerous example programs that demonstrate SMTP and POP3/IMAP functions used to create mail applications using the SEE4D library.
SEE4D runs under all versions of Windows (Windows 95, Windows 98, Windows ME, Windows 2000, Windows 2003, Windows NT, Windows XP, Windows Vista and Windows 7). The SMTP/POP3/IMAP Email Engine SDK DLLs (SEE32.DLL or SEE64.DLL) can also be used from any language (C/C++, .NET, Visual Basic, VB .NET, Visual FoxPro, COBOL, Xbase++, dBase, PowerBASIC, etc.) capable of calling the Windows API.
When comparing the SMTP/POP3/IMAP Email component library against our competition, note that:
MarshallSoft also has versions of the SMTP/POP3/IMAP Email Engine library for C/C++ (SEE4C), Visual Basic (SEE4VB), PowerBASIC (SEE4PB), Visual FoxPro (SEE4FP), Visual dBASE (SEE4DB), Xbase++ (SEE4XB) and COBOL (SEE4CB). All versions of the SEE library use the same DLLs (SEE32.DLL and SEE64.DLL). However, the examples provided for each version are written for the specified programming language.
The latest versions of SMTP/POP3/IMAP Email Engine (SEE) can be downloaded from our web site at
http://www.marshallsoft.com/email-component-library.htm
Our goal is to provide a robust SMTP/POP3/IMAP email component library that you and your
customers can depend upon. A fully functional evaluation version is available. Contact
us if you have any questions.
Some of the many features of SMTP/POP3/IMAP Email Engine component library are as follows:
The complete set of documentation consists of three manuals in Adobe PDF format. This is the first manual (SEE_4D) in the set.
The SEE_4D Programmer's Manual is the language specific (Delphi) manual. All language dependent programming issues such as compiling, compilers and example programs are discussed in this manual. Read this manual first.
The SEE User's Manual (SEE_USR) discusses email processing as well as language independent programming issues. Purchasing and licensing details are also provided.
The SEE Reference Manual (SEE_REF) contains details on each individual SEE function. A list of error codes is also provided.
Online documentation can be accessed on the SMTP/POP3/IMAP Email Engine for Delphi product page at:
http://www.marshallsoft.com/see4d.htm
The following example demonstrates the use of some of the SMTP/POP3/IMAP Email for Delphi component library functions. It uses the SEEW.PAS unit that is discussed in Section 3.2 below.
var
Code : Integer;
SmtpHost : String;
SmtpFrom : String;
Text : String;
Empty : String;
SmtpTo : String;
begin
Empty := Chr(0);
SmtpHost := 'mail.your-isp.com';
SmtpFrom := '<you@your-isp.com'>';
SmtpTo := '<someone@their-isp.com>';
{create email message}
Text := 'This is a test message ' + Chr(13) + Chr(10)
+ '-- marshallsoft' + Chr(13) + Chr(10);
{attach SEE}
Code := fAttach(1, 0);
if Code < 0 then
begin
Text := Format('Cannot attach SEE (error %d)',[Code]);
DisplayLine(send.eResult, Text);
exit
end;
{connect to SMTP server}
Code := fSmtpConnect(0, SmtpHost, SmtpFrom, Empty);
if Code < 0 then
begin
DisplayError(send.eResult, Code);
fRelease;
exit
end;
{send email}
Code := fSendEmail(0, SmtpTo, Empty, Empty, 'Your order', Text, Empty);
if Code < 0 then
begin
DisplayError(send.eResult, Code);
exit
end;
{close}
fClose(0);
fRelease
end;
In the example program above, fAttach is called to initialize SEE and then fSmtpConnect is called to connect to the SMTP mail host. The SMTP server host name and your email address are required, while the "Reply-To" entry is optional.
fSendEmail is then called, passing the addressee lists. The primary addressee is provided in the "To List". The CC ("Carbon Copy") lists additional recipients, as does the BCC (Blind Carbon Copy) list. The subject contains the email subject line. The message text is next. If it starts with the '@' symbol, it is considered the name of the file containing the email message. Lastly, the filename of any ASCII or binary attachment is specified. All fields, except the first field, in seeSendEmail are optional
After returning from seeSendEmail, the seeClose function is called to close the connection to the SMTP server. Lastly, fRelease is called to perform SEE termination processing and release the Winsock.
Note that the install process does not modify the Windows registry.
Uninstalling SEE4D is very easy. SEE does not modify the registry.
First, run UINSTALL.BAT, which will delete SEE32.DLL from your Windows directory, typically C:\WINDOWS for Windows 95/98/ME/XP/2003/Vista/Win7 or C:\WINNT for Windows NT/2000.
Second, delete the SEE project directory created when installing SEE4D.
A developer license for the SMTP/POP3/IMAP Email Library can be purchased for $115 USD.
Order using INVOICE.TXT provided with the evaluation version or order directly on our web site at
http://www.marshallsoft.com/order.htm
Registration includes one year of free updates and technical support. The registered DLL never expires.
When a developer license is purchased, the developer will be sent a registered DLL plus a license file (SEExxxx.LIC, where xxxx is your Customer ID). The license file can be used to update the registered DLL's for a period of one year from purchase. Updates can be downloaded from
http://www.marshallsoft.com/update.htm
After one year, the developer license must be updated to be able to download updates. The license can be updated for $30 if ordered within one year of the original purchase (or previous update). Between one year and three years, licenses can be updated for $55. After three years, updates are $75. The license includes technical support.
Note that registered DLL does not expire; however, the ability to download version updates expires after one year. Refer to the file UPDATES.TXT located in the /SEE4D/DOCS directory for more information.
The SMTP/POP3/IMAP Email component library has been tested on multiple computers running Windows 95/98/Me/XP/2003/Vista/Windows 7 and Windows NT/2000.
The SEE4D library has been tested and works with all versions of Borland (CodeGear) Delphi including Delphi 2 - Delphi 8, Delphi 2005 - Delphi 2010 and Turbo Delphi.
The SETUP installation program will copy the SEE DLL to the Windows directory and copies the SEE4D files to the directory specified (default \SEE4D). Three sub-directories are created, as follows:
DOCS - All documentation files
APPS - All example code
DLLS - All DLL's
The SMTP/POP3/IMAP Email component library uses a Win32 dynamic link library (DLL). A DLL is characterized by the fact that it need not be loaded until required by an application program and that only one copy of the DLL is necessary regardless of the number of application programs that use it. Contrast this to the traditional static library that is bound to each and every application that uses it at link time.
An important advantage that DLL's have over other "popular" library formats such as VBX or OCX is that DLL's are callable by all Windows applications. Since DLL's are the building blocks of the Windows Operating System, they will not be replaced by a "newer technology".
The SEE32.DLL has a keycode encoded within it. The keycode is a 9 or 10 digit decimal number and will be found in the file KEYCODE.PAS. The keycode for the evaluation version is 0. The developer will receive a new keycode and a new SEE32.DLL after purchasing a license. The KEYCODE is passed to seeAttach.
If you get an error message (value -74) when calling seeAttach, it means that the keycode in your application does not match the keycode in the DLL. After registering, it is best to remove the evaluation version of the SEE32.DLL from the Windows search path or delete it.
SEE32 is written in ANSI C and is compiled using the _stdcall and _declspec keywords. This means that SEE4D uses the same calling conventions and file naming conventions as the Win32 API. In particular, function names are NOT decorated. There are neither leading underscores nor trailing "@size" strings added to function names.
Any Windows application program may call the SEE library provided that the proper declaration file is used.
The error message text associated with SEE error codes can be displayed by calling seeErrorText. Each sample program contains examples of error processing.
Also see the file seeErrors.txt for a list of all Winsock and SEE error codes.
If you are running Delphi for .NET, copy SEE32UC.PAS to the same directory as your application program. If you are running Delphi for Win32 (Delphi 2 and above), copy SEE32.PAS. Also copy the file KEYCODE.PAS to this same directory. You will find these files in the APPS directory (folder) created when you ran SETUP, usually C:\SEE4D\APPS.
Next, add a reference to the files copied above to your "uses" clause in your application program. For example,
uses
see32, keycode, ...
You can leave 'keycode' out above if you put your numerical keycode value (found in KEYCODE.PAS) directly into the call to SioAttach. For example,
{pass the key code}
Code := SioAttach(123456789) < 0 then ...
Lastly, add a reference to SEE32 to your project file (*.DPR). For example,
uses
SEE32 in 'SEE32.PAS', ...
The SMTP/POP3/IMAP Email Engine for Delphi component library supports all versions of CodeGear (Borland) Delphi for Win32 as well as Delphi for .NET as follows:
Applications written with Delphi link with the same identical DLL as for applications written in all other supported languages, such as C/C++ and Visual Basic.
The first release of Borland Delphi (version 1) generated Win16 code.
SEE4D does not support 16-bit applications.
Delphi version 2 and above generates Win32 code and link with SEE32DLL. Strings can be much larger than 255 bytes.
Delphi 2 seems to have a problem with some of the string functions. Although the default is "large strings", some of the string functions (such as StrPas) copy only 255 bytes. The MYSTRING.PAS unit contains a replacement unit to use instead of StrPCopy.
Delphi 3 also has some problems with PChar string functions such as StrPCopy. See the previous section.
There are no known Delphi problems impacting our example programs in Delphi version 4 and above.
Beginning in Delphi 7, the filename of a unit must match the unit name. Delphi 8 was a .NET only release.
The Delphi 2005/2006/2007 compilers support both Win32 and the Microsoft .NET Framework.
When loading Delphi for Win32 projects with Delphi 2005/2006/2007, a window entitled "Project Upgrade" will be displayed:
This project must be upgraded before it can be opened. Please select which project type you wish to target:
( ) Delphi for .NET
( ) Delphi for Win32
Choose "Delphi for Win32" for all projects except "*.bdsproj" projects, which are Delphi for .NET projects.
In Delphi 2009 the definition of PChar was changed from a pointer to a 8-bit character to a pointer to a 16-bit character, also known as a "wide character". For this reason PAnsiChar must be used rather than PChar for pointers to buffers that are passed to SEE functions. Refer to the Win32 example programs in the APPS directory.
The SEEW.PAS module is a "wrapper" for SEE.PAS that allows you to pass Delphi strings directly rather than having to first convert them to PCHAR variables. Strings in SEE, like Windows itself, are in reality buffers terminated by a null (0) character. Implementing SEE in this way allows SEE functions to be called by any language capable of calling the Windows API. Note that wrapper functions (defined in SEEW.PAS) are named beginning with the letter 'f'. For instance, "fAttach" is the wrapper function that calls "seeAttach".
Nevertheless, it is certainly more convenient to pass Delphi strings rather than zero terminated buffers. Compare the two following code segments:
{call using SEE -- pass pointers to null terminated buffers}
var
Code : Integer;
HostPtr : PAnsiChar;
UserPtr : PAnsiChar;
PassPtr : PAnsiChar;
Begin
GetMem(HostPtr, 64); StrPCopy(HostPtr, 'mail.marshallsoft.com');
GetMem(UserPtr, 64); StrPCopy(UserPtr, 'mike');
GetMem(PassPtr, 64); StrPCopy(PassPtr, 'qwerty');
Code := seePop3Connect(0, HostPtr, UserPtr, PassPtr);
FreeMem(HostPtr,64); FreeMem(UserPtr,64); FreeMem(PassPtr,64);
. . .
{call using SEEW -- pass Delphi strings}
. . .
Code := fPop3Connect(0, 'mail.marshallsoft.com', 'mike', 'qwerty');
. . .
Beginning with Delphi 2003, Delphi has two "personalities": (1) Win32 Delphi and (2) Delphi for .NET. Win32 Delphi programs are a continuation of the Delphi language as seen in earlier versions of Delphi. Delphi .NET is a version of Delphi designed to use the Microsoft .NET Framework.
The example programs are compiled from the Delphi development environment using the provided Delphi project files (*.DPR).
Refer to Section 4.0 "Example Programs" for more details on each of the example programs.
SMTP programs send email, while POP3/IMAP programs check and download mail.
Each of the following example programs use the "display" unit and the "SEE" unit:
DISPLAY.PAS : Display unit source code.
SEE.PAS : SEE Unit source code.
A few of the example programs also use the "SEE Wrapper" unit, SEEW.PAS, as described in Section 3.2.
SEEW.PAS : SEE Wrapper unit source code.
The DISPLAY.PAS unit is used to display text in Delphi memos. DISPLAY.PAS contains 4 procedures:
DisplayChar : Displays character.
DisplayString : Displays string.
DisplayLine : Displays line.
DisplayError : Displays error message.
Delphi for .NET projects must be compiled with Delphi for .NET 2005/2006/2007. See section 3.1.
Several example programs do not require a connection to a server.
This simple program displays the SEE version number, build number, and registration string taken from SEE32.DLL. Its purpose is display the SEE version, build, and registration string as well as to verify that SEE32.DLL is being found and loaded by Windows The VERSION program does not attempt to connect to any server.
The Delphi for Win32 VERSION project files are:
VER_PRJ.DPR : Delphi project file.
VER_PGM.DFM : Delphi form file.
VER_PGM.PAS : Program source code.
The CODETEST example program demonstrates how to use seeEncodeBuffer and seeDecodeBuffer, which BASE64 encodes and decodes several test strings. The CODETEST example program also demonstrates the use of seeEncodeUTF8 and seeDecodeUTF8.
The Delphi for Win32 CODETEST project files are:
CODE_PRJ.DPR : Delphi project file.
CODE_PGM.DFM : Delphi form file.
CODE_PGM.PAS : Program source code.
This is the Delphi for .NET equivalent of the Delphi for Win32 VERSION program.
The Delphi for .NET project files are:
Version_Project.bdsproj : Delphi for .NET project file
Version_Project.dpr : Delphi for .NET project file
Version_WinForm.pas : Delphi for .NET form source
Version_WinForm.resx : Delphi for .NET resource file
Version_WinForm.TWinForm.resources : Delphi for .NET resource file
There are twelve SMTP email example programs. SMTP programs send email using an SMTP server.
AUTHENTICATE is an example program that connects to an SMTP (ESMTP) server using SMTP Authentication. You must connect to an SMTP server that allows authentication.
The Delphi for Win32 AUTH project files are:
AUTH_PRJ.DPR : Delphi project file.
AUTH_PGM.DFM : Delphi form file.
AUTH_PGM.PAS : Program source code.
AUTO ("auto-responder") uses two channels to read email on the POP3 server and at the same time automatically responds to all new email using the SMTP server. Edit the TCP/IP parameters in AUTO_PGM.PAS (line 82) before compiling. AUTO uses the SEEW.PAS wrapper unit.
The Delphi for Win32 AUTO project files are:
AUTO_PRJ.DPR : Delphi project file.
AUTO_PGM.DFM : Delphi form file.
AUTO_PGM.PAS : Program source code.
The BROADCAST example program emails the same message to each recipient from a file of email addresses. Along with your SMTP server and your email address, you must create the file containing the email message to send, and create another file containing the list of recipients. See BCAST.EML for an example.
The Delphi for Win32 BCAST project files are:
BCST_PRJ.DPR : Delphi project file.
BCST_PGM.DFM : Delphi form file.
BCST_PGM.PAS : Program source code.
The FORWARD example program forwards an email message to a new recipient. Only undecoded email messages can be forwarded.
Undecoded email message can be downloaded using the GETRAW and READER example programs.
The Delphi for Win32 FORWARD project files are:
FWD_PRJ.DPR : Delphi project file.
FWD_PGM.DFM : Delphi form file.
FWD_PGM.PAS : Program source code.
The HELLO program emails a short message. Before compiling, HELO_PGM.PAS must be edited (about line 43) with your email parameters. HELLO uses the SEE wrapper unit (SEEW.PAS).
The HELLO project files are:
HELO_PRJ.DPR : Delphi project file.
HELO_PGM.DFM : Delphi form file.
HELO_PGM.PAS : Program source code.
Compare Delphi for Win32 HELLO with the MAILER example program.
The HTML example program connects to an SMTP server and emails an HTML encoded file (HTML.HTM)containing inline embedded graphics (IMAGE1.GIF and IMAGE2.GIF) as well as an alternate text file (HTML.TXT).
Note that the defaults are read from the file HTML.INI at runtime.
The Delphi for Win32 HTML project files are:
HTML_PRJ.DPR : Delphi project file.
HTML_PGM.DFM : Delphi form file.
HTML_PGM.PAS : Program source code.
The ISO 8859 example program sends a text message and subject line that are ISO-8859 encoded. The recipient's email client will be able to display the email message using the specified ISO character set provided that it is capable of identifying ISO-8859 MIME parts (such as MS OutLook).
The Delphi for Win32 ISO 8859 project files are:
ISO_PRJ.DPR : Delphi project file.
ISO_PGM.DFM : Delphi form file.
ISO_PGM.PAS : Program source code.
The GB 2312 example program sends a text message that is GB2312 (simplified Chinese) encoded. The recipient's email client will be able to display the email message using the specified GB2312 character set provided that it is capable of identifying GB2312 MIME parts (such as MS OutLook).
The Delphi for Win32 GB 2312 project files are:
GB_PRJ.DPR : Delphi project file.
GB_PGM.DFM : Delphi form file.
GB_PGM.PAS : Program source code.
The GMVP ("Gmail Via Proxy") example program emails a specified email message connecting to a GMAIL account via the (free) STUNNEL proxy server that is started and terminated without user intervention. See gmail.txt in the DOCS directory or http://www.marshallsoft.com/gmail.htm for more information on STUNNEL
The Delphi for Win32 GMVP project files are:
GMVP_PRJ.DPR : Delphi project file.
GMVP_PGM.DFM : Delphi form file.
GMVP_PGM.PAS : Program source code.
The MAILER example program emails a message, including optional MIME attachments.
The Delphi for Win32 MAILER project files are:
MAIL_PRJ.DPR : Delphi project file.
MAIL_PGM.DFM : Delphi form file.
MAIL_PGM.PAS : Program source code.
Note that the MAILER program uses the "indirect" method (refer to the SMTP/POP3/IMAP User's Manual SEE_USR, Section_6.1, "Indirect Method" (http:/www.marshallsoft.com/see_usr.htm#Section_6.1) The function seeDriver is called automatically. An hourglass cursor is displayed while your email is being sent to the server.
This is the Delphi 2005/2006/2007 NET equivalent of the Delphi for Win32 MAILER program above.
The Delphi for .NET project files are:
Mailer_Project.bdsproj : Delphi for .NET project file
Mailer_Project.dpr : Delphi for .NET project file
Mailer_WinForm.pas : Delphi for .NET form source
Mailer_WinForm.resx : Delphi for .NET resource file
Mailer_WinForm.TWinForm.resources : Delphi for .NET resource file
The PART example program sends a multipart MIME email in which the programmer specifies the Content-Type headers for each attachment.
The two attachment types specified in this example are a sound file (.wav) and a PDF file (.pdf).
The Delphi for Win32 PART project files are:
PART_PRJ.DPR : Delphi project file.
PART_PGM.DFM : Delphi form file.
PART_PGM.PAS : Program source code.
There are six POP3 email example programs that read email using the POP3 server or IMAP server.
AUTO ("auto-responder") uses two channels concurrently to read email on the POP3 server and at the same time automatically respond to all new email using the SMTP server. Edit the TCP/IP parameters in AUTO_PGM.PAS (line 82) before compiling. AUTO uses the SEEW.PAS wrapper unit.
The Delphi for Win32 AUTO project files are:
AUTO_PRJ.DPR : Delphi project file.
AUTO_PGM.DFM : Delphi form file.
AUTO_PGM.PAS : Program source code.
GETRAW is an example program that downloads a specified email message without decoding it (in "raw" format). This is used to see what the email looks like on the server. Also see the READER example program, which can also download email without decoding it.
All required parameters are taken from the dialog box at runtime.
The Delphi for Win32 project files are:
GRAW_PRJ.DPR : Delphi project file.
GRAW_PGM.DFM : Delphi form file.
GRAW_PGM.PAS : Program source code.
The Pop3Read example program uses the seePop3Source function to specify an (undecoded) email message file to be read and decoded.
The Delphi for Win32 Pop3Read project files are:
POP3_PRJ.DPR : Delphi project file.
POP3_PGM.DFM : Delphi form file.
POP3_PGM.PAS : Program source code.
READER can read email, including multiple MIME attachments, from your POP3 server, optionally deleting each email after being read.
The Delphi for Win32 READER project files are:
READ_PRJ.DPR : Delphi project file.
READ_PGM.DFM : Delphi form file.
READ_PGM.PAS : Program source code.
Note that the READER program uses the "direct method" (refer to SMTP/POP3/IMAP User's Manual SEE_USR). The seeDriver is explicitly called. The progress of the incoming email is displayed.
The READER program can also download email without decoding. See the note "PROGRAMMER" in READ_PGM.PAS
STATUS reads the number of email messages waiting on a POP3 server, and displays the "DATE:", "FROM:", and "SUBJECT:" header fields from each email.
The Delphi for Win32 STATUS project files are:
STAT_PRJ.DPR : Delphi project file.
STAT_PGM.DFM : Delphi form file.
STAT_PGM.PAS : Program source code.
This is the Delphi 2005/2006/2007 NET equivalent of the Delphi for Win32 STATUS project above.
The Delphi for .NET project files are:
Status_Project.bdsproj : Delphi for .NET project file
Status_Project.dpr : Delphi for .NET project file
Status_WinForm.pas : Delphi for .NET form source
Status_WinForm.resx : Delphi for .NET resource file
Status_WinForm.TWinForm.resources : Delphi for .NET resource file
There are four IMAP-only email example programs. These examples access the IMAP server.
The ImapFlagsT example program tests the manipulation of flags on the IMAP server. It reads, sets, and deletes certain flags for the specified email message on the IMAP server.
IMAP flags are:
\Seen Message has been read
\Answered Message has been answered
\Flagged Message is "flagged" for urgent/special attention
\Deleted Message is "deleted" for removal by later EXPUNGE
\Draft Message has not completed composition (marked as a draft).
\Recent Message has arrived since the previous time this mailbox was
selected. ["\Recent" may be fetched but not stored]
The Delphi for Win32 project files are:
ImapFlagsT_PRJ.DPR : Delphi project file.
ImapFlagsT_PGM.DFM : Delphi form file.
ImapFlagsT_PGM.PAS : Program source code.
The ImapFlagsT_Project example program is the Delphi for .NET equivalent of the Delphi for Win32 ImapFlagsT project.
The Delphi for .NET project files are:
ImapFlagsT_Project.bdsproj : Delphi for .NET project file
ImapFlagsT_Project.dpr : Delphi for .NET project file
ImapFlagsT_WinForm.pas : Delphi for .NET form source
ImapFlagsT_WinForm.resx : Delphi for .NET resource file
ImapFlagsT_WinForm.TWinForm.resources : Delphi for .NET resource file
The ImapSearch example program tests IMAP search capability.
See ImapSearch.txt or http://www.marshallsoft.com/ImapSearch.htm for a complete list of all IMAP search strings.
Example search strings as passed to seeImapSearch():
SEEN
SEEN NOT ANSWERED
FLAGGED SINCE 1-Feb-2008 NOT FROM "Smith"
LARGER 10000 NOT SEEN
The Delphi for Win32 project files are:
ImapSearch_PRJ.DPR : Delphi project file.
ImapSearch_PGM.DFM : Delphi form file.
ImapSearch_PGM.PAS : Program source code.
The ImapSearch_Project example program is the Delphi for .NET equivalent of the Delphi for Win32 ImapSearch project.:
The Delphi for .NET project files are:
ImapSearch_Project.bdsproj : Delphi for .NET project file
ImapSearch_Project.dpr : Delphi for .NET project file
ImapSearch_WinForm.pas : Delphi for .NET form source
ImapSearch_WinForm.resx : Delphi for .NET resource file
ImapSearch_WinForm.TWinForm.resources : Delphi for .NET resource file
The SMTP/POP3/IMAP Email Engine DLL (SEE32.DLL) is written in ANSI C. All programming language versions of SEE (C/C++, .NET, Visual Basic, VB .NET, PowerBASIC, Visual FoxPro, Delphi, dBase, Xbase++, COBOL, and Fortran) use the same SEE32.DLL.
Version 1.0: June 22, 1998
Version 2.0: September 28, 1998.
Version 2.1: November 28, 1998.
Version 3.0: April 12, 1999.
Version 3.1: July 16, 1999.
Version 3.2: February 7, 2000.
Version 3.3: October 3, 2000
Version 3.4: July 24, 2001
Version 3.5: March 5, 2002
Version 3.6: March 20, 2003
Version 3.7: January 28, 2005.
Version 4.0: August 17, 2006.
Version 5.0: May 14, 2008 (Win32 Version only)
Version 5.1: May 13, 2009 (Win32 and Win64) versions
Version 5.2: April 15, 2010 (Win32) version