wined3d: Use surface_is_offscreen() in fb_copy_to_texture_hwstretch().
[wine] / dlls / mapi32 / mapi32_main.c
1 /*
2  *             MAPI basics
3  *
4  * Copyright 2001, 2009 CodeWeavers Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "objbase.h"
27 #include "initguid.h"
28 #include "mapix.h"
29 #include "mapiform.h"
30 #include "mapi.h"
31 #include "wine/debug.h"
32 #include "util.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(mapi);
35
36 LONG MAPI_ObjectCount = 0;
37
38 /***********************************************************************
39  *              DllMain (MAPI32.init)
40  */
41 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
42 {
43     TRACE("(%p,%d,%p)\n", hinstDLL, fdwReason, fImpLoad);
44
45     switch (fdwReason)
46     {
47     case DLL_PROCESS_ATTACH:
48         DisableThreadLibraryCalls(hinstDLL);
49         load_mapi_providers();
50         break;
51     case DLL_PROCESS_DETACH:
52         TRACE("DLL_PROCESS_DETACH: %d objects remaining\n", MAPI_ObjectCount);
53         unload_mapi_providers();
54         break;
55     }
56     return TRUE;
57 }
58
59 /***********************************************************************
60  *              DllGetClassObject (MAPI32.27)
61  */
62 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
63 {
64     if (mapiFunctions.DllGetClassObject)
65     {
66         HRESULT ret = mapiFunctions.DllGetClassObject(rclsid, iid, ppv);
67
68         TRACE("ret: %x\n", ret);
69         return ret;
70     }
71
72     FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
73
74     *ppv = NULL;
75     return CLASS_E_CLASSNOTAVAILABLE;
76 }
77
78 /***********************************************************************
79  * DllCanUnloadNow (MAPI32.28)
80  *
81  * Determine if this dll can be unloaded from the callers address space.
82  *
83  * PARAMS
84  *  None.
85  *
86  * RETURNS
87  *  S_OK, if the dll can be unloaded,
88  *  S_FALSE, otherwise.
89  */
90 HRESULT WINAPI DllCanUnloadNow(void)
91 {
92     HRESULT ret = S_OK;
93
94     if (mapiFunctions.DllCanUnloadNow)
95     {
96         ret = mapiFunctions.DllCanUnloadNow();
97         TRACE("(): provider returns %d\n", ret);
98     }
99
100     return MAPI_ObjectCount == 0 ? ret : S_FALSE;
101 }
102
103 /***********************************************************************
104  * MAPIInitialize
105  *
106  * Initialises the MAPI library. In our case, we pass through to the
107  * loaded Extended MAPI provider.
108  */
109 HRESULT WINAPI MAPIInitialize(LPVOID init)
110 {
111     TRACE("(%p)\n", init);
112
113     if (mapiFunctions.MAPIInitialize)
114         return mapiFunctions.MAPIInitialize(init);
115
116     return MAPI_E_NOT_INITIALIZED;
117 }
118
119 /***********************************************************************
120  * MAPILogon
121  *
122  * Logs on to a MAPI provider. If available, we pass this through to a
123  * Simple MAPI provider. Otherwise, we maintain basic functionality
124  * ourselves.
125  */
126 ULONG WINAPI MAPILogon(ULONG_PTR uiparam, LPSTR profile, LPSTR password,
127     FLAGS flags, ULONG reserved, LPLHANDLE session)
128 {
129     TRACE("(0x%08lx %s %p 0x%08x 0x%08x %p)\n", uiparam,
130           debugstr_a(profile), password, flags, reserved, session);
131
132     if (mapiFunctions.MAPILogon)
133         return mapiFunctions.MAPILogon(uiparam, profile, password, flags, reserved, session);
134
135     if (session) *session = 1;
136     return SUCCESS_SUCCESS;
137 }
138
139 /***********************************************************************
140  * MAPILogoff
141  *
142  * Logs off from a MAPI provider. If available, we pass this through to a
143  * Simple MAPI provider. Otherwise, we maintain basic functionality
144  * ourselves.
145  */
146 ULONG WINAPI MAPILogoff(LHANDLE session, ULONG_PTR uiparam, FLAGS flags,
147     ULONG reserved )
148 {
149     TRACE("(0x%08lx 0x%08lx 0x%08x 0x%08x)\n", session,
150           uiparam, flags, reserved);
151
152     if (mapiFunctions.MAPILogoff)
153         return mapiFunctions.MAPILogoff(session, uiparam, flags, reserved);
154
155     return SUCCESS_SUCCESS;
156 }
157
158 /***********************************************************************
159  * MAPILogonEx
160  *
161  * Logs on to a MAPI provider. If available, we pass this through to an
162  * Extended MAPI provider. Otherwise, we return an error.
163  */
164 HRESULT WINAPI MAPILogonEx(ULONG_PTR uiparam, LPWSTR profile,
165     LPWSTR password, ULONG flags, LPMAPISESSION *session)
166 {
167     TRACE("(0x%08lx %s %p 0x%08x %p)\n", uiparam,
168           debugstr_w(profile), password, flags, session);
169
170     if (mapiFunctions.MAPILogonEx)
171         return mapiFunctions.MAPILogonEx(uiparam, profile, password, flags, session);
172
173     return E_FAIL;
174 }
175
176 HRESULT WINAPI MAPIOpenLocalFormContainer(LPVOID *ppfcnt)
177 {
178     if (mapiFunctions.MAPIOpenLocalFormContainer)
179         return mapiFunctions.MAPIOpenLocalFormContainer(ppfcnt);
180
181     FIXME("(%p) Stub\n", ppfcnt);
182     return E_FAIL;
183 }
184
185 /***********************************************************************
186  * MAPIUninitialize
187  *
188  * Uninitialises the MAPI library. In our case, we pass through to the
189  * loaded Extended MAPI provider.
190  *
191  */
192 VOID WINAPI MAPIUninitialize(void)
193 {
194     TRACE("()\n");
195
196     /* Try to uninitialise the Extended MAPI library */
197     if (mapiFunctions.MAPIUninitialize)
198         mapiFunctions.MAPIUninitialize();
199 }
200
201 HRESULT WINAPI MAPIAdminProfiles(ULONG ulFlags,  LPPROFADMIN *lppProfAdmin)
202 {
203     if (mapiFunctions.MAPIAdminProfiles)
204         return mapiFunctions.MAPIAdminProfiles(ulFlags, lppProfAdmin);
205
206     FIXME("(%u, %p): stub\n", ulFlags, lppProfAdmin);
207     *lppProfAdmin = NULL;
208     return E_FAIL;
209 }
210
211 ULONG WINAPI MAPIAddress(LHANDLE session, ULONG_PTR uiparam, LPSTR caption,
212     ULONG editfields, LPSTR labels, ULONG nRecips, lpMapiRecipDesc lpRecips,
213     FLAGS flags, ULONG reserved, LPULONG newRecips, lpMapiRecipDesc * lppNewRecips)
214 {
215     if (mapiFunctions.MAPIAddress)
216         return mapiFunctions.MAPIAddress(session, uiparam, caption, editfields, labels,
217             nRecips, lpRecips, flags, reserved, newRecips, lppNewRecips);
218
219     return MAPI_E_NOT_SUPPORTED;
220 }
221
222 ULONG WINAPI MAPIDeleteMail(LHANDLE session, ULONG_PTR uiparam, LPSTR msg_id,
223     FLAGS flags, ULONG reserved)
224 {
225     if (mapiFunctions.MAPIDeleteMail)
226         return mapiFunctions.MAPIDeleteMail(session, uiparam, msg_id, flags, reserved);
227
228     return MAPI_E_NOT_SUPPORTED;
229 }
230
231 ULONG WINAPI MAPIDetails(LHANDLE session, ULONG_PTR uiparam, lpMapiRecipDesc recip,
232     FLAGS flags, ULONG reserved)
233 {
234     if (mapiFunctions.MAPIDetails)
235         return mapiFunctions.MAPIDetails(session, uiparam, recip, flags, reserved);
236
237     return MAPI_E_NOT_SUPPORTED;
238 }
239
240 ULONG WINAPI MAPIFindNext(LHANDLE session, ULONG_PTR uiparam, LPSTR msg_type,
241     LPSTR seed_msg_id, FLAGS flags, ULONG reserved, LPSTR msg_id)
242 {
243     if (mapiFunctions.MAPIFindNext)
244         return mapiFunctions.MAPIFindNext(session, uiparam, msg_type, seed_msg_id, flags, reserved, msg_id);
245
246     return MAPI_E_NOT_SUPPORTED;
247 }
248
249 ULONG WINAPI MAPIReadMail(LHANDLE session, ULONG_PTR uiparam, LPSTR msg_id,
250     FLAGS flags, ULONG reserved, lpMapiMessage msg)
251 {
252     if (mapiFunctions.MAPIReadMail)
253         return mapiFunctions.MAPIReadMail(session, uiparam, msg_id, flags, reserved, msg);
254
255     return MAPI_E_NOT_SUPPORTED;
256 }
257
258 ULONG WINAPI MAPIResolveName(LHANDLE session, ULONG_PTR uiparam, LPSTR name,
259     FLAGS flags, ULONG reserved, lpMapiRecipDesc *recip)
260 {
261     if (mapiFunctions.MAPIResolveName)
262         return mapiFunctions.MAPIResolveName(session, uiparam, name, flags, reserved, recip);
263
264     return MAPI_E_NOT_SUPPORTED;
265 }
266
267 ULONG WINAPI MAPISaveMail(LHANDLE session, ULONG_PTR uiparam, lpMapiMessage msg,
268     FLAGS flags, ULONG reserved, LPSTR msg_id)
269 {
270     if (mapiFunctions.MAPISaveMail)
271         return mapiFunctions.MAPISaveMail(session, uiparam, msg, flags, reserved, msg_id);
272
273     return MAPI_E_NOT_SUPPORTED;
274 }