[wxWidgets.git] / contrib / src / net / smapi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        smapi.cpp
// Purpose:     Simple MAPI classes
// Author:      PJ Naughter <pjna@naughter.com>
// Modified by: Julian Smart
// Created:     2001-08-21
// RCS-ID:      $Id$
// Copyright:   (c) PJ Naughter
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifdef __WXMSW__

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/string.h"
#include "wx/msw/private.h"

// mapi.h in Cygwin's include directory isn't a full implementation and is
// not sufficient for this lib. However recent versions of Cygwin also
// have another mapi.h in include/w32api which can be used.
//
#ifdef __CYGWIN__
#include <w32api/mapi.h>
#else
#include <mapi.h>
#endif

#include "wx/net/smapi.h"

class WXDLLIMPEXP_NETUTILS wxMapiData
{
public:
    wxMapiData()
    {
        m_hSession = 0;
        m_nLastError = 0;
        m_hMapi = NULL;
        m_lpfnMAPILogon = NULL;
        m_lpfnMAPILogoff = NULL;
        m_lpfnMAPISendMail = NULL;
        m_lpfnMAPIResolveName = NULL;
        m_lpfnMAPIFreeBuffer = NULL;
    }

    //Data
    LHANDLE             m_hSession; //Mapi Session handle
    long                m_nLastError; //Last Mapi error value
    HINSTANCE           m_hMapi; //Instance handle of the MAPI dll
    LPMAPILOGON         m_lpfnMAPILogon; //MAPILogon function pointer
    LPMAPILOGOFF        m_lpfnMAPILogoff; //MAPILogoff function pointer
    LPMAPISENDMAIL      m_lpfnMAPISendMail; //MAPISendMail function pointer
    LPMAPIRESOLVENAME   m_lpfnMAPIResolveName; //MAPIResolveName function pointer
    LPMAPIFREEBUFFER    m_lpfnMAPIFreeBuffer; //MAPIFreeBuffer function pointer
};


////////////////////////////////// Implementation /////////////////////////////

wxMapiSession::wxMapiSession()
{
    m_data = new wxMapiData;
    
    Initialise();
}

wxMapiSession::~wxMapiSession()
{
    //Logoff if logged on
    Logoff();
    
    //Unload the MAPI dll
    Deinitialise();
    
    delete m_data;
}

void wxMapiSession::Initialise() 
{
    //First make sure the "WIN.INI" entry for MAPI is present aswell 
    //as the MAPI32 dll being present on the system
    bool bMapiInstalled = (GetProfileInt(_T("MAIL"), _T("MAPI"), 0) != 0) && 
        (SearchPath(NULL, _T("MAPI32.DLL"), NULL, 0, NULL, NULL) != 0);
    
    if (bMapiInstalled)
    {
        //Load up the MAPI dll and get the function pointers we are interested in
        m_data->m_hMapi = ::LoadLibrary(_T("MAPI32.DLL"));
        if (m_data->m_hMapi)
        {
            m_data->m_lpfnMAPILogon = (LPMAPILOGON) GetProcAddress(m_data->m_hMapi, "MAPILogon");
            m_data->m_lpfnMAPILogoff = (LPMAPILOGOFF) GetProcAddress(m_data->m_hMapi, "MAPILogoff");
            m_data->m_lpfnMAPISendMail = (LPMAPISENDMAIL) GetProcAddress(m_data->m_hMapi, "MAPISendMail");
            m_data->m_lpfnMAPIResolveName = (LPMAPIRESOLVENAME) GetProcAddress(m_data->m_hMapi, "MAPIResolveName");
            m_data->m_lpfnMAPIFreeBuffer = (LPMAPIFREEBUFFER) GetProcAddress(m_data->m_hMapi, "MAPIFreeBuffer");
            
            //If any of the functions are not installed then fail the load
            if (m_data->m_lpfnMAPILogon == NULL ||
                m_data->m_lpfnMAPILogoff == NULL ||
                m_data->m_lpfnMAPISendMail == NULL ||
                m_data->m_lpfnMAPIResolveName == NULL ||
                m_data->m_lpfnMAPIFreeBuffer == NULL)
            {
                wxLogDebug(_T("Failed to get one of the functions pointer in MAPI32.DLL\n"));
                Deinitialise();
            }
        }
    }
    else
        wxLogDebug(_T("Mapi is not installed on this computer\n"));
}

void wxMapiSession::Deinitialise()
{
    if (m_data->m_hMapi)
    {
        //Unload the MAPI dll and reset the function pointers to NULL
        FreeLibrary(m_data->m_hMapi);
        m_data->m_hMapi = NULL;
        m_data->m_lpfnMAPILogon = NULL;
        m_data->m_lpfnMAPILogoff = NULL;
        m_data->m_lpfnMAPISendMail = NULL;
        m_data->m_lpfnMAPIResolveName = NULL;
        m_data->m_lpfnMAPIFreeBuffer = NULL;
    }
}

bool wxMapiSession::Logon(const wxString& sProfileName, const wxString& sPassword, wxWindow* pParentWnd)
{
    wxASSERT(MapiInstalled()); //MAPI must be installed
    wxASSERT(m_data->m_lpfnMAPILogon); //Function pointer must be valid
    
    //Initialise the function return value
    bool bSuccess = FALSE;
    
    //Just in case we are already logged in
    Logoff();
    
    //Setup the ascii versions of the profile name and password
    int nProfileLength = sProfileName.Length();
    
    LPSTR pszProfileName = NULL;
    LPSTR pszPassword = NULL;
    wxCharBuffer cbProfile(1),cbPassword(1);
    if (nProfileLength)
    {
#ifndef UNICODE
        pszProfileName = (LPSTR) sProfileName.c_str();
        pszPassword = (LPSTR) sPassword.c_str();
#else
        cbProfile = sProfileName.mb_str();
        cbPassword = sPassword.mb_str();
        pszProfileName = cbProfile.data();
        pszPassword = cbPassword.data();
#endif
    }
    
    //Setup the flags & UIParam parameters used in the MapiLogon call
    FLAGS flags = 0;
    ULONG nUIParam = 0;
    if (nProfileLength == 0)
    {
        //No profile name given, then we must interactively request a profile name
        if (pParentWnd)
        {
            nUIParam = (ULONG) (HWND) pParentWnd->GetHWND();
            flags |= MAPI_LOGON_UI;
        }
        else
        {
            //No window given, just use the main window of the app as the parent window
            if (wxTheApp->GetTopWindow())
            {
                nUIParam = (ULONG) (HWND) wxTheApp->GetTopWindow()->GetHWND();
                flags |= MAPI_LOGON_UI;
            }
        }
    }
    
    //First try to acquire a new MAPI session using the supplied settings using the MAPILogon functio
    ULONG nError = m_data->m_lpfnMAPILogon(nUIParam, pszProfileName, pszPassword, flags | MAPI_NEW_SESSION, 0, &m_data->m_hSession);
    if (nError != SUCCESS_SUCCESS && nError != MAPI_E_USER_ABORT)
    {
        //Failed to create a create mapi session, try to acquire a shared mapi session
        wxLogDebug(_T("Failed to logon to MAPI using a new session, trying to acquire a shared one\n"));
        nError = m_data->m_lpfnMAPILogon(nUIParam, NULL, NULL, 0, 0, &m_data->m_hSession);
        if (nError == SUCCESS_SUCCESS)
        {
            m_data->m_nLastError = SUCCESS_SUCCESS;
            bSuccess = TRUE;
        }
        else
        {
            wxLogDebug(_T("Failed to logon to MAPI using a shared session, Error:%ld\n"), nError);
            m_data->m_nLastError = nError;
        }
    }
    else if (nError == SUCCESS_SUCCESS)
    {
        m_data->m_nLastError = SUCCESS_SUCCESS;
        bSuccess = TRUE;
    }
    
    return bSuccess;
}

bool wxMapiSession::LoggedOn() const
{
    return (m_data->m_hSession != 0);
}

bool wxMapiSession::MapiInstalled() const
{
    return (m_data->m_hMapi != NULL);
}

bool wxMapiSession::Logoff()
{
    wxASSERT(MapiInstalled()); //MAPI must be installed
    wxASSERT(m_data->m_lpfnMAPILogoff); //Function pointer must be valid
    
    //Initialise the function return value
    bool bSuccess = FALSE;
    
    if (m_data->m_hSession)
    {
        //Call the MAPILogoff function
        ULONG nError = m_data->m_lpfnMAPILogoff(m_data->m_hSession, 0, 0, 0); 
        if (nError != SUCCESS_SUCCESS)
        {
            wxLogDebug(_T("Failed in call to MapiLogoff, Error:%ld"), nError);
            m_data->m_nLastError = nError;
            bSuccess = TRUE;
        }
        else
        {
            m_data->m_nLastError = SUCCESS_SUCCESS;
            bSuccess = TRUE;
        }
        m_data->m_hSession = 0;
    }
    
    return bSuccess;
}

bool wxMapiSession::Resolve(const wxString& sName, void* lppRecip1)
{
    lpMapiRecipDesc* lppRecip = (lpMapiRecipDesc*) lppRecip1;
    
    wxASSERT(MapiInstalled()); //MAPI must be installed
    wxASSERT(m_data->m_lpfnMAPIResolveName); //Function pointer must be valid
    wxASSERT(LoggedOn()); //Must be logged on to MAPI
    wxASSERT(m_data->m_hSession); //MAPI session handle must be valid
    
    //Call the MAPIResolveName function
#ifndef UNICODE
    LPSTR lpszAsciiName = (LPSTR) sName.c_str();
#else
    wxCharBuffer cbName(1);
    cbName = sName.mb_str();
    LPSTR lpszAsciiName = cbName.data();
#endif
    ULONG nError = m_data->m_lpfnMAPIResolveName(m_data->m_hSession, 0, lpszAsciiName, 0, 0, lppRecip);
    if (nError != SUCCESS_SUCCESS)
    {
        wxLogDebug(_T("Failed to resolve the name: %s, Error:%ld\n"),
                   sName.c_str(), nError);
        m_data->m_nLastError = nError;
    }
    
    return (nError == SUCCESS_SUCCESS);
}

bool wxMapiSession::Send(wxMailMessage& message)
{
    wxASSERT(MapiInstalled()); //MAPI must be installed
    wxASSERT(m_data->m_lpfnMAPISendMail); //Function pointer must be valid
    wxASSERT(m_data->m_lpfnMAPIFreeBuffer); //Function pointer must be valid
    wxASSERT(LoggedOn()); //Must be logged on to MAPI
    wxASSERT(m_data->m_hSession); //MAPI session handle must be valid
    
    //Initialise the function return value
    bool bSuccess = FALSE;  
    
    //Create the MapiMessage structure to match the message parameter send into us
    MapiMessage mapiMessage;
    ZeroMemory(&mapiMessage, sizeof(mapiMessage));
#ifndef UNICODE
    mapiMessage.lpszSubject = (LPSTR) message.m_subject.c_str();
    mapiMessage.lpszNoteText = (LPSTR) message.m_body.c_str();
#else
    wxCharBuffer cbSubject(1),cbBody(1),cbOriginator(1);
    cbSubject = message.m_subject.mb_str();
    cbBody = message.m_body.mb_str();
    mapiMessage.lpszSubject = cbSubject.data();
    mapiMessage.lpszNoteText = cbBody.data();
#endif
    mapiMessage.nRecipCount = message.m_to.GetCount() + message.m_cc.GetCount() + message.m_bcc.GetCount();
    wxASSERT(mapiMessage.nRecipCount); //Must have at least 1 recipient!
    
    //Allocate the recipients array
    mapiMessage.lpRecips = new MapiRecipDesc[mapiMessage.nRecipCount];

    // If we have a 'From' field, use it
    if (!message.m_from.IsEmpty())
    {
        mapiMessage.lpOriginator = new MapiRecipDesc;
        ZeroMemory(mapiMessage.lpOriginator, sizeof(MapiRecipDesc));

        mapiMessage.lpOriginator->ulRecipClass = MAPI_ORIG;
        // TODO Do we have to call Resolve?
#ifndef UNICODE
        mapiMessage.lpOriginator->lpszName = (LPSTR) message.m_from.c_str();
#else
        cbOriginator = message.m_from.mb_str();
        mapiMessage.lpOriginator->lpszName = cbOriginator.data();
#endif
    }
    
    //Setup the "To" recipients
    int nRecipIndex = 0;
    int nToSize = message.m_to.GetCount();
    int i;
    for (i=0; i<nToSize; i++)
    {
        MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
        ZeroMemory(&recip, sizeof(MapiRecipDesc));
        recip.ulRecipClass = MAPI_TO;
        wxString& sName = message.m_to[i];

        //Try to resolve the name
        lpMapiRecipDesc lpTempRecip;  
        if (Resolve(sName, (void*) &lpTempRecip))
        {
            //Resolve worked, put the resolved name back into the sName
            sName = wxString(lpTempRecip->lpszName,*wxConvCurrent);
            
            //Don't forget to free up the memory MAPI allocated for us
            m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
        }
#ifndef UNICODE
        recip.lpszName = (LPSTR) sName.c_str();
#else
        recip.lpszName = sName.mb_str().release();
#endif
        
        ++nRecipIndex;
    }
    
    //Setup the "CC" recipients
    int nCCSize = message.m_cc.GetCount();
    for (i=0; i<nCCSize; i++)
    {
        MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
        ZeroMemory(&recip, sizeof(MapiRecipDesc));
        recip.ulRecipClass = MAPI_CC;
        wxString& sName = message.m_cc[i];

        //Try to resolve the name
        lpMapiRecipDesc lpTempRecip;  
        if (Resolve(sName, (void*) &lpTempRecip))
        {
            //Resolve worked, put the resolved name back into the sName
            sName = wxString(lpTempRecip->lpszName,*wxConvCurrent);
            
            //Don't forget to free up the memory MAPI allocated for us
            m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
        }
#ifndef UNICODE
        recip.lpszName = (LPSTR) sName.c_str();
#else
        recip.lpszName = sName.mb_str().release();
#endif
        
        ++nRecipIndex;
    }
    
    //Setup the "BCC" recipients
    int nBCCSize = message.m_bcc.GetCount();
    for (i=0; i<nBCCSize; i++)
    {
        MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
        ZeroMemory(&recip, sizeof(MapiRecipDesc));
        recip.ulRecipClass = MAPI_BCC;
        wxString& sName = message.m_bcc[i];

        //Try to resolve the name
        lpMapiRecipDesc lpTempRecip;  
        if (Resolve(sName, (void*) &lpTempRecip))
        {
            //Resolve worked, put the resolved name back into the sName
            sName = wxString(lpTempRecip->lpszName,wxConvCurrent);
            
            //Don't forget to free up the memory MAPI allocated for us
            m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
        }
#ifndef UNICODE
        recip.lpszName = (LPSTR) sName.c_str();
#else
        recip.lpszName = sName.mb_str().release();
#endif
        
        ++nRecipIndex;
    }
    
    //Setup the attachments 
    int nAttachmentSize = message.m_attachments.GetCount();
    int nTitleSize = message.m_attachmentTitles.GetCount();
    if (nTitleSize)
    { 
        wxASSERT(nTitleSize == nAttachmentSize); //If you are going to set the attachment titles then you must set 
        //the attachment title for each attachment
    }
    if (nAttachmentSize)
    {
        mapiMessage.nFileCount = nAttachmentSize;
        mapiMessage.lpFiles = new MapiFileDesc[nAttachmentSize];
        for (i=0; i<nAttachmentSize; i++)
        {
            MapiFileDesc& file = mapiMessage.lpFiles[i];
            ZeroMemory(&file, sizeof(MapiFileDesc));
            file.nPosition = 0xFFFFFFFF;
            wxString& sFilename = message.m_attachments[i];

#ifndef UNICODE
            file.lpszPathName = (LPSTR) sFilename.c_str();
#else
            file.lpszPathName = sFilename.mb_str().release();
#endif
            //file.lpszFileName = file.lpszPathName;
            file.lpszFileName = NULL;

            if (nTitleSize && !message.m_attachmentTitles[i].IsEmpty())
            {
                wxString& sTitle = message.m_attachmentTitles[i];
#ifndef UNICODE
                file.lpszFileName = (LPSTR) sTitle.c_str();
#else
                file.lpszFileName = sTitle.mb_str().release();
#endif
            }
        }
    }
    
    //Do the actual send using MAPISendMail
    ULONG nError = m_data->m_lpfnMAPISendMail(m_data->m_hSession, 0, &mapiMessage, MAPI_DIALOG, 0);
    if (nError == SUCCESS_SUCCESS)
    {
        bSuccess = TRUE;
        m_data->m_nLastError = SUCCESS_SUCCESS;
    }
    else
    {
        wxLogDebug(_T("Failed to send mail message, Error:%ld\n"), nError);
        m_data->m_nLastError = nError;
    }
    
    //Tidy up the Attachements
    if (nAttachmentSize)
    {
#ifdef UNICODE
        for (i = 0;i < nAttachmentSize;i++)
        {
            free(mapiMessage.lpFiles[i].lpszPathName);
            free(mapiMessage.lpFiles[i].lpszFileName);
        }
#endif
        delete [] mapiMessage.lpFiles;
    }
    
    //Free up the Recipients and Originator memory
#ifdef UNICODE
    for (i = 0;i < nRecipIndex;i++)
        free(mapiMessage.lpRecips[i].lpszName);
#endif
    delete [] mapiMessage.lpRecips;

    delete mapiMessage.lpOriginator;
    
    return bSuccess;
}

long wxMapiSession::GetLastError() const
{
    return m_data->m_nLastError;
}

#endif // __WXMSW__
Commit	Line	Data
decb3a6a JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: smapi.cpp
	3	// Purpose: Simple MAPI classes
	4	// Author: PJ Naughter <pjna@naughter.com>
	5	// Modified by: Julian Smart
	6	// Created: 2001-08-21
	7	// RCS-ID: $Id$
	8	// Copyright: (c) PJ Naughter
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
decb3a6a JS	12	// For compilers that support precompilation, includes "wx/wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
5f109709 MB	19	#ifdef __WXMSW__
5f109709 MB	20
decb3a6a JS	21	#ifndef WX_PRECOMP
	22	#include "wx/wx.h"
	23	#endif
	24
	25	#include "wx/string.h"
	26	#include "wx/msw/private.h"
	27
508c5a09 MW	28	// mapi.h in Cygwin's include directory isn't a full implementation and is
	29	// not sufficient for this lib. However recent versions of Cygwin also
	30	// have another mapi.h in include/w32api which can be used.
	31	//
	32	#ifdef __CYGWIN__
	33	#include <w32api/mapi.h>
	34	#else
decb3a6a	35	#include <mapi.h>
508c5a09	36	#endif
decb3a6a JS	37
	38	#include "wx/net/smapi.h"
	39
15e8daec	40	class WXDLLIMPEXP_NETUTILS wxMapiData
decb3a6a JS	41	{
	42	public:
	43	wxMapiData()
	44	{
	45	m_hSession = 0;
	46	m_nLastError = 0;
	47	m_hMapi = NULL;
	48	m_lpfnMAPILogon = NULL;
	49	m_lpfnMAPILogoff = NULL;
	50	m_lpfnMAPISendMail = NULL;
	51	m_lpfnMAPIResolveName = NULL;
	52	m_lpfnMAPIFreeBuffer = NULL;
	53	}
	54
	55	//Data
	56	LHANDLE m_hSession; //Mapi Session handle
	57	long m_nLastError; //Last Mapi error value
	58	HINSTANCE m_hMapi; //Instance handle of the MAPI dll
	59	LPMAPILOGON m_lpfnMAPILogon; //MAPILogon function pointer
	60	LPMAPILOGOFF m_lpfnMAPILogoff; //MAPILogoff function pointer
	61	LPMAPISENDMAIL m_lpfnMAPISendMail; //MAPISendMail function pointer
	62	LPMAPIRESOLVENAME m_lpfnMAPIResolveName; //MAPIResolveName function pointer
	63	LPMAPIFREEBUFFER m_lpfnMAPIFreeBuffer; //MAPIFreeBuffer function pointer
	64	};
	65
	66
	67	////////////////////////////////// Implementation /////////////////////////////
	68
	69	wxMapiSession::wxMapiSession()
	70	{
	71	m_data = new wxMapiData;
	72
	73	Initialise();
	74	}
	75
	76	wxMapiSession::~wxMapiSession()
	77	{
	78	//Logoff if logged on
	79	Logoff();
	80
	81	//Unload the MAPI dll
	82	Deinitialise();
	83
	84	delete m_data;
	85	}
	86
	87	void wxMapiSession::Initialise()
	88	{
	89	//First make sure the "WIN.INI" entry for MAPI is present aswell
	90	//as the MAPI32 dll being present on the system
	91	bool bMapiInstalled = (GetProfileInt(_T("MAIL"), _T("MAPI"), 0) != 0) &&
	92	(SearchPath(NULL, _T("MAPI32.DLL"), NULL, 0, NULL, NULL) != 0);
	93
	94	if (bMapiInstalled)
	95	{
	96	//Load up the MAPI dll and get the function pointers we are interested in
	97	m_data->m_hMapi = ::LoadLibrary(_T("MAPI32.DLL"));
	98	if (m_data->m_hMapi)
	99	{
	100	m_data->m_lpfnMAPILogon = (LPMAPILOGON) GetProcAddress(m_data->m_hMapi, "MAPILogon");
	101	m_data->m_lpfnMAPILogoff = (LPMAPILOGOFF) GetProcAddress(m_data->m_hMapi, "MAPILogoff");
	102	m_data->m_lpfnMAPISendMail = (LPMAPISENDMAIL) GetProcAddress(m_data->m_hMapi, "MAPISendMail");
	103	m_data->m_lpfnMAPIResolveName = (LPMAPIRESOLVENAME) GetProcAddress(m_data->m_hMapi, "MAPIResolveName");
	104	m_data->m_lpfnMAPIFreeBuffer = (LPMAPIFREEBUFFER) GetProcAddress(m_data->m_hMapi, "MAPIFreeBuffer");
105
106	//If any of the functions are not installed then fail the load
107	if (m_data->m_lpfnMAPILogon == NULL \|\|
108	m_data->m_lpfnMAPILogoff == NULL \|\|
109	m_data->m_lpfnMAPISendMail == NULL \|\|
110	m_data->m_lpfnMAPIResolveName == NULL \|\|
111	m_data->m_lpfnMAPIFreeBuffer == NULL)
112	{
113	wxLogDebug(_T("Failed to get one of the functions pointer in MAPI32.DLL\n"));
114	Deinitialise();
115	}
116	}
117	}
118	else
119	wxLogDebug(_T("Mapi is not installed on this computer\n"));
120	}
121
122	void wxMapiSession::Deinitialise()
123	{
124	if (m_data->m_hMapi)
125	{
126	//Unload the MAPI dll and reset the function pointers to NULL
127	FreeLibrary(m_data->m_hMapi);
128	m_data->m_hMapi = NULL;
129	m_data->m_lpfnMAPILogon = NULL;
130	m_data->m_lpfnMAPILogoff = NULL;
131	m_data->m_lpfnMAPISendMail = NULL;
132	m_data->m_lpfnMAPIResolveName = NULL;
133	m_data->m_lpfnMAPIFreeBuffer = NULL;
134	}
135	}
136
137	bool wxMapiSession::Logon(const wxString& sProfileName, const wxString& sPassword, wxWindow* pParentWnd)
138	{
139	wxASSERT(MapiInstalled()); //MAPI must be installed
140	wxASSERT(m_data->m_lpfnMAPILogon); //Function pointer must be valid
141
142	//Initialise the function return value
143	bool bSuccess = FALSE;
144
145	//Just in case we are already logged in
146	Logoff();
147
148	//Setup the ascii versions of the profile name and password
149	int nProfileLength = sProfileName.Length();
decb3a6a JS	150
	151	LPSTR pszProfileName = NULL;
	152	LPSTR pszPassword = NULL;
5a618a14	153	wxCharBuffer cbProfile(1),cbPassword(1);
decb3a6a JS	154	if (nProfileLength)
decb3a6a JS	155	{
5a618a14	156	#ifndef UNICODE
decb3a6a JS	157	pszProfileName = (LPSTR) sProfileName.c_str();
decb3a6a JS	158	pszPassword = (LPSTR) sPassword.c_str();
5a618a14 JS	159	#else
	160	cbProfile = sProfileName.mb_str();
	161	cbPassword = sPassword.mb_str();
	162	pszProfileName = cbProfile.data();
	163	pszPassword = cbPassword.data();
	164	#endif
decb3a6a JS	165	}
	166
	167	//Setup the flags & UIParam parameters used in the MapiLogon call
	168	FLAGS flags = 0;
	169	ULONG nUIParam = 0;
	170	if (nProfileLength == 0)
	171	{
	172	//No profile name given, then we must interactively request a profile name
	173	if (pParentWnd)
	174	{
	175	nUIParam = (ULONG) (HWND) pParentWnd->GetHWND();
	176	flags \|= MAPI_LOGON_UI;
	177	}
	178	else
	179	{
	180	//No window given, just use the main window of the app as the parent window
	181	if (wxTheApp->GetTopWindow())
	182	{
	183	nUIParam = (ULONG) (HWND) wxTheApp->GetTopWindow()->GetHWND();
	184	flags \|= MAPI_LOGON_UI;
	185	}
	186	}
	187	}
	188
	189	//First try to acquire a new MAPI session using the supplied settings using the MAPILogon functio
	190	ULONG nError = m_data->m_lpfnMAPILogon(nUIParam, pszProfileName, pszPassword, flags \| MAPI_NEW_SESSION, 0, &m_data->m_hSession);
	191	if (nError != SUCCESS_SUCCESS && nError != MAPI_E_USER_ABORT)
	192	{
	193	//Failed to create a create mapi session, try to acquire a shared mapi session
	194	wxLogDebug(_T("Failed to logon to MAPI using a new session, trying to acquire a shared one\n"));
	195	nError = m_data->m_lpfnMAPILogon(nUIParam, NULL, NULL, 0, 0, &m_data->m_hSession);
	196	if (nError == SUCCESS_SUCCESS)
	197	{
	198	m_data->m_nLastError = SUCCESS_SUCCESS;
	199	bSuccess = TRUE;
	200	}
	201	else
	202	{
9409aa35	203	wxLogDebug(_T("Failed to logon to MAPI using a shared session, Error:%ld\n"), nError);
decb3a6a JS	204	m_data->m_nLastError = nError;
	205	}
	206	}
	207	else if (nError == SUCCESS_SUCCESS)
	208	{
	209	m_data->m_nLastError = SUCCESS_SUCCESS;
	210	bSuccess = TRUE;
	211	}
	212
	213	return bSuccess;
	214	}
	215
	216	bool wxMapiSession::LoggedOn() const
	217	{
	218	return (m_data->m_hSession != 0);
	219	}
	220
	221	bool wxMapiSession::MapiInstalled() const
	222	{
	223	return (m_data->m_hMapi != NULL);
	224	}
	225
	226	bool wxMapiSession::Logoff()
	227	{
	228	wxASSERT(MapiInstalled()); //MAPI must be installed
	229	wxASSERT(m_data->m_lpfnMAPILogoff); //Function pointer must be valid
	230
	231	//Initialise the function return value
	232	bool bSuccess = FALSE;
	233
	234	if (m_data->m_hSession)
	235	{
	236	//Call the MAPILogoff function
	237	ULONG nError = m_data->m_lpfnMAPILogoff(m_data->m_hSession, 0, 0, 0);
	238	if (nError != SUCCESS_SUCCESS)
	239	{
9409aa35	240	wxLogDebug(_T("Failed in call to MapiLogoff, Error:%ld"), nError);
decb3a6a JS	241	m_data->m_nLastError = nError;
	242	bSuccess = TRUE;
	243	}
	244	else
	245	{
	246	m_data->m_nLastError = SUCCESS_SUCCESS;
	247	bSuccess = TRUE;
	248	}
	249	m_data->m_hSession = 0;
	250	}
	251
	252	return bSuccess;
	253	}
	254
	255	bool wxMapiSession::Resolve(const wxString& sName, void* lppRecip1)
	256	{
	257	lpMapiRecipDesc* lppRecip = (lpMapiRecipDesc*) lppRecip1;
	258
	259	wxASSERT(MapiInstalled()); //MAPI must be installed
	260	wxASSERT(m_data->m_lpfnMAPIResolveName); //Function pointer must be valid
	261	wxASSERT(LoggedOn()); //Must be logged on to MAPI
	262	wxASSERT(m_data->m_hSession); //MAPI session handle must be valid
	263
	264	//Call the MAPIResolveName function
5a618a14	265	#ifndef UNICODE
decb3a6a	266	LPSTR lpszAsciiName = (LPSTR) sName.c_str();
5a618a14 JS	267	#else
	268	wxCharBuffer cbName(1);
	269	cbName = sName.mb_str();
	270	LPSTR lpszAsciiName = cbName.data();
	271	#endif
decb3a6a JS	272	ULONG nError = m_data->m_lpfnMAPIResolveName(m_data->m_hSession, 0, lpszAsciiName, 0, 0, lppRecip);
	273	if (nError != SUCCESS_SUCCESS)
	274	{
9409aa35 JS	275	wxLogDebug(_T("Failed to resolve the name: %s, Error:%ld\n"),
9409aa35 JS	276	sName.c_str(), nError);
decb3a6a JS	277	m_data->m_nLastError = nError;
	278	}
	279
	280	return (nError == SUCCESS_SUCCESS);
	281	}
	282
	283	bool wxMapiSession::Send(wxMailMessage& message)
	284	{
	285	wxASSERT(MapiInstalled()); //MAPI must be installed
	286	wxASSERT(m_data->m_lpfnMAPISendMail); //Function pointer must be valid
	287	wxASSERT(m_data->m_lpfnMAPIFreeBuffer); //Function pointer must be valid
	288	wxASSERT(LoggedOn()); //Must be logged on to MAPI
	289	wxASSERT(m_data->m_hSession); //MAPI session handle must be valid
	290
	291	//Initialise the function return value
	292	bool bSuccess = FALSE;
	293
	294	//Create the MapiMessage structure to match the message parameter send into us
	295	MapiMessage mapiMessage;
	296	ZeroMemory(&mapiMessage, sizeof(mapiMessage));
5a618a14	297	#ifndef UNICODE
decb3a6a JS	298	mapiMessage.lpszSubject = (LPSTR) message.m_subject.c_str();
decb3a6a JS	299	mapiMessage.lpszNoteText = (LPSTR) message.m_body.c_str();
5a618a14 JS	300	#else
	301	wxCharBuffer cbSubject(1),cbBody(1),cbOriginator(1);
	302	cbSubject = message.m_subject.mb_str();
	303	cbBody = message.m_body.mb_str();
	304	mapiMessage.lpszSubject = cbSubject.data();
	305	mapiMessage.lpszNoteText = cbBody.data();
	306	#endif
decb3a6a JS	307	mapiMessage.nRecipCount = message.m_to.GetCount() + message.m_cc.GetCount() + message.m_bcc.GetCount();
	308	wxASSERT(mapiMessage.nRecipCount); //Must have at least 1 recipient!
	309
	310	//Allocate the recipients array
	311	mapiMessage.lpRecips = new MapiRecipDesc[mapiMessage.nRecipCount];
a23c0047 JS	312
	313	// If we have a 'From' field, use it
	314	if (!message.m_from.IsEmpty())
	315	{
	316	mapiMessage.lpOriginator = new MapiRecipDesc;
	317	ZeroMemory(mapiMessage.lpOriginator, sizeof(MapiRecipDesc));
	318
	319	mapiMessage.lpOriginator->ulRecipClass = MAPI_ORIG;
	320	// TODO Do we have to call Resolve?
5a618a14	321	#ifndef UNICODE
a23c0047	322	mapiMessage.lpOriginator->lpszName = (LPSTR) message.m_from.c_str();
5a618a14 JS	323	#else
	324	cbOriginator = message.m_from.mb_str();
	325	mapiMessage.lpOriginator->lpszName = cbOriginator.data();
	326	#endif
a23c0047	327	}
decb3a6a JS	328
	329	//Setup the "To" recipients
	330	int nRecipIndex = 0;
	331	int nToSize = message.m_to.GetCount();
cceb71da MB	332	int i;
cceb71da MB	333	for (i=0; i<nToSize; i++)
decb3a6a JS	334	{
	335	MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
	336	ZeroMemory(&recip, sizeof(MapiRecipDesc));
	337	recip.ulRecipClass = MAPI_TO;
	338	wxString& sName = message.m_to[i];
	339
	340	//Try to resolve the name
	341	lpMapiRecipDesc lpTempRecip;
	342	if (Resolve(sName, (void*) &lpTempRecip))
	343	{
	344	//Resolve worked, put the resolved name back into the sName
9409aa35	345	sName = wxString(lpTempRecip->lpszName,*wxConvCurrent);
decb3a6a JS	346
	347	//Don't forget to free up the memory MAPI allocated for us
	348	m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
	349	}
5a618a14	350	#ifndef UNICODE
decb3a6a	351	recip.lpszName = (LPSTR) sName.c_str();
5a618a14 JS	352	#else
	353	recip.lpszName = sName.mb_str().release();
	354	#endif
decb3a6a JS	355
	356	++nRecipIndex;
	357	}
	358
	359	//Setup the "CC" recipients
	360	int nCCSize = message.m_cc.GetCount();
	361	for (i=0; i<nCCSize; i++)
	362	{
	363	MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
	364	ZeroMemory(&recip, sizeof(MapiRecipDesc));
	365	recip.ulRecipClass = MAPI_CC;
	366	wxString& sName = message.m_cc[i];
	367
	368	//Try to resolve the name
	369	lpMapiRecipDesc lpTempRecip;
	370	if (Resolve(sName, (void*) &lpTempRecip))
	371	{
	372	//Resolve worked, put the resolved name back into the sName
9409aa35	373	sName = wxString(lpTempRecip->lpszName,*wxConvCurrent);
decb3a6a JS	374
	375	//Don't forget to free up the memory MAPI allocated for us
	376	m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
	377	}
5a618a14	378	#ifndef UNICODE
decb3a6a	379	recip.lpszName = (LPSTR) sName.c_str();
5a618a14 JS	380	#else
	381	recip.lpszName = sName.mb_str().release();
	382	#endif
decb3a6a JS	383
	384	++nRecipIndex;
	385	}
	386
	387	//Setup the "BCC" recipients
	388	int nBCCSize = message.m_bcc.GetCount();
	389	for (i=0; i<nBCCSize; i++)
	390	{
	391	MapiRecipDesc& recip = mapiMessage.lpRecips[nRecipIndex];
	392	ZeroMemory(&recip, sizeof(MapiRecipDesc));
	393	recip.ulRecipClass = MAPI_BCC;
	394	wxString& sName = message.m_bcc[i];
	395
	396	//Try to resolve the name
	397	lpMapiRecipDesc lpTempRecip;
	398	if (Resolve(sName, (void*) &lpTempRecip))
	399	{
	400	//Resolve worked, put the resolved name back into the sName
5a618a14	401	sName = wxString(lpTempRecip->lpszName,wxConvCurrent);
decb3a6a JS	402
	403	//Don't forget to free up the memory MAPI allocated for us
	404	m_data->m_lpfnMAPIFreeBuffer(lpTempRecip);
	405	}
5a618a14	406	#ifndef UNICODE
decb3a6a	407	recip.lpszName = (LPSTR) sName.c_str();
5a618a14 JS	408	#else
	409	recip.lpszName = sName.mb_str().release();
	410	#endif
decb3a6a JS	411
	412	++nRecipIndex;
	413	}
	414
	415	//Setup the attachments
	416	int nAttachmentSize = message.m_attachments.GetCount();
	417	int nTitleSize = message.m_attachmentTitles.GetCount();
	418	if (nTitleSize)
	419	{
	420	wxASSERT(nTitleSize == nAttachmentSize); //If you are going to set the attachment titles then you must set
	421	//the attachment title for each attachment
	422	}
	423	if (nAttachmentSize)
	424	{
	425	mapiMessage.nFileCount = nAttachmentSize;
	426	mapiMessage.lpFiles = new MapiFileDesc[nAttachmentSize];
	427	for (i=0; i<nAttachmentSize; i++)
	428	{
	429	MapiFileDesc& file = mapiMessage.lpFiles[i];
	430	ZeroMemory(&file, sizeof(MapiFileDesc));
	431	file.nPosition = 0xFFFFFFFF;
	432	wxString& sFilename = message.m_attachments[i];
decb3a6a	433
5a618a14	434	#ifndef UNICODE
decb3a6a	435	file.lpszPathName = (LPSTR) sFilename.c_str();
5a618a14 JS	436	#else
	437	file.lpszPathName = sFilename.mb_str().release();
	438	#endif
decb3a6a JS	439	//file.lpszFileName = file.lpszPathName;
	440	file.lpszFileName = NULL;
	441
	442	if (nTitleSize && !message.m_attachmentTitles[i].IsEmpty())
	443	{
	444	wxString& sTitle = message.m_attachmentTitles[i];
5a618a14	445	#ifndef UNICODE
decb3a6a	446	file.lpszFileName = (LPSTR) sTitle.c_str();
5a618a14 JS	447	#else
	448	file.lpszFileName = sTitle.mb_str().release();
	449	#endif
decb3a6a JS	450	}
	451	}
	452	}
	453
	454	//Do the actual send using MAPISendMail
	455	ULONG nError = m_data->m_lpfnMAPISendMail(m_data->m_hSession, 0, &mapiMessage, MAPI_DIALOG, 0);
	456	if (nError == SUCCESS_SUCCESS)
	457	{
	458	bSuccess = TRUE;
	459	m_data->m_nLastError = SUCCESS_SUCCESS;
	460	}
	461	else
	462	{
9409aa35	463	wxLogDebug(_T("Failed to send mail message, Error:%ld\n"), nError);
decb3a6a JS	464	m_data->m_nLastError = nError;
	465	}
	466
	467	//Tidy up the Attachements
	468	if (nAttachmentSize)
5a618a14 JS	469	{
5a618a14 JS	470	#ifdef UNICODE
c59f3b2d	471	for (i = 0;i < nAttachmentSize;i++)
5a618a14 JS	472	{
	473	free(mapiMessage.lpFiles[i].lpszPathName);
	474	free(mapiMessage.lpFiles[i].lpszFileName);
	475	}
	476	#endif
decb3a6a	477	delete [] mapiMessage.lpFiles;
5a618a14	478	}
decb3a6a	479
a23c0047	480	//Free up the Recipients and Originator memory
5a618a14	481	#ifdef UNICODE
c59f3b2d	482	for (i = 0;i < nRecipIndex;i++)
5a618a14 JS	483	free(mapiMessage.lpRecips[i].lpszName);
5a618a14 JS	484	#endif
decb3a6a	485	delete [] mapiMessage.lpRecips;
5a618a14	486
a23c0047	487	delete mapiMessage.lpOriginator;
decb3a6a JS	488
	489	return bSuccess;
	490	}
	491
	492	long wxMapiSession::GetLastError() const
	493	{
	494	return m_data->m_nLastError;
	495	}
5f109709 MB	496
5f109709 MB	497	#endif // __WXMSW__