comctl32/tests: Fix some test failures on older comctl32 versions.
[wine] / dlls / mscms / handle.c
1 /*
2  * MSCMS - Color Management System for Wine
3  *
4  * Copyright 2004, 2005, 2008 Hans Leidekker
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 "config.h"
22 #include "wine/debug.h"
23
24 #include <stdarg.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "icm.h"
31
32 #include "mscms_priv.h"
33
34 #ifdef HAVE_LCMS
35
36 static CRITICAL_SECTION MSCMS_handle_cs;
37 static CRITICAL_SECTION_DEBUG MSCMS_handle_cs_debug =
38 {
39     0, 0, &MSCMS_handle_cs,
40     { &MSCMS_handle_cs_debug.ProcessLocksList,
41       &MSCMS_handle_cs_debug.ProcessLocksList },
42       0, 0, { (DWORD_PTR)(__FILE__ ": MSCMS_handle_cs") }
43 };
44 static CRITICAL_SECTION MSCMS_handle_cs = { &MSCMS_handle_cs_debug, -1, 0, 0, 0, 0 };
45
46 static struct profile *profiletable;
47 static struct transform *transformtable;
48
49 static unsigned int num_profile_handles;
50 static unsigned int num_transform_handles;
51
52 WINE_DEFAULT_DEBUG_CHANNEL(mscms);
53
54 void free_handle_tables( void )
55 {
56     HeapFree( GetProcessHeap(), 0, profiletable );
57     profiletable = NULL;
58     num_profile_handles = 0;
59
60     HeapFree( GetProcessHeap(), 0, transformtable );
61     transformtable = NULL;
62     num_transform_handles = 0;
63 }
64
65 struct profile *grab_profile( HPROFILE handle )
66 {
67     DWORD_PTR index;
68
69     EnterCriticalSection( &MSCMS_handle_cs );
70
71     index = (DWORD_PTR)handle - 1;
72     if (index > num_profile_handles)
73     {
74         LeaveCriticalSection( &MSCMS_handle_cs );
75         return NULL;
76     }
77     return &profiletable[index];
78 }
79
80 void release_profile( struct profile *profile )
81 {
82     LeaveCriticalSection( &MSCMS_handle_cs );
83 }
84
85 struct transform *grab_transform( HTRANSFORM handle )
86 {
87     DWORD_PTR index;
88
89     EnterCriticalSection( &MSCMS_handle_cs );
90
91     index = (DWORD_PTR)handle - 1;
92     if (index > num_transform_handles)
93     {
94         LeaveCriticalSection( &MSCMS_handle_cs );
95         return NULL;
96     }
97     return &transformtable[index];
98 }
99
100 void release_transform( struct transform *transform )
101 {
102     LeaveCriticalSection( &MSCMS_handle_cs );
103 }
104
105 static HPROFILE alloc_profile_handle( void )
106 {
107     DWORD_PTR index;
108     struct profile *p;
109     unsigned int count = 128;
110
111     for (index = 0; index < num_profile_handles; index++)
112     {
113         if (!profiletable[index].iccprofile) return (HPROFILE)(index + 1);
114     }
115     if (!profiletable)
116     {
117         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct profile) );
118     }
119     else
120     {
121         count = num_profile_handles * 2;
122         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, profiletable, count * sizeof(struct profile) );
123     }
124     if (!p) return NULL;
125
126     profiletable = p;
127     num_profile_handles = count;
128
129     return (HPROFILE)(index + 1);
130 }
131
132 HPROFILE create_profile( struct profile *profile )
133 {
134     HPROFILE handle;
135
136     EnterCriticalSection( &MSCMS_handle_cs );
137
138     if ((handle = alloc_profile_handle()))
139     {
140         DWORD_PTR index = (DWORD_PTR)handle - 1;
141         memcpy( &profiletable[index], profile, sizeof(struct profile) );
142     }
143     LeaveCriticalSection( &MSCMS_handle_cs );
144     return handle;
145 }
146
147 BOOL close_profile( HPROFILE handle )
148 {
149     DWORD_PTR index;
150     struct profile *profile;
151
152     EnterCriticalSection( &MSCMS_handle_cs );
153
154     index = (DWORD_PTR)handle - 1;
155     if (index > num_profile_handles)
156     {
157         LeaveCriticalSection( &MSCMS_handle_cs );
158         return FALSE;
159     }
160     profile = &profiletable[index];
161
162     if (profile->file != INVALID_HANDLE_VALUE)
163     {
164         if (profile->access & PROFILE_READWRITE)
165         {
166             DWORD written, size = MSCMS_get_profile_size( profile->iccprofile );
167
168             if (SetFilePointer( profile->file, 0, NULL, FILE_BEGIN ) ||
169                 !WriteFile( profile->file, profile->iccprofile, size, &written, NULL ) ||
170                 written != size)
171             {
172                 ERR( "Unable to write color profile\n" );
173             }
174         }
175         CloseHandle( profile->file );
176     }
177     cmsCloseProfile( profile->cmsprofile );
178     HeapFree( GetProcessHeap(), 0, profile->iccprofile );
179
180     memset( profile, 0, sizeof(struct profile) );
181
182     LeaveCriticalSection( &MSCMS_handle_cs );
183     return TRUE;
184 }
185
186 static HTRANSFORM alloc_transform_handle( void )
187 {
188     DWORD_PTR index;
189     struct transform *p;
190     unsigned int count = 128;
191
192     for (index = 0; index < num_transform_handles; index++)
193     {
194         if (!transformtable[index].cmstransform) return (HTRANSFORM)(index + 1);
195     }
196     if (!transformtable)
197     {
198         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct transform) );
199     }
200     else
201     {
202         count = num_transform_handles * 2;
203         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, transformtable, count * sizeof(struct transform) );
204     }
205     if (!p) return NULL;
206
207     transformtable = p;
208     num_transform_handles = count;
209
210     return (HTRANSFORM)(index + 1);
211 }
212
213 HTRANSFORM create_transform( struct transform *transform )
214 {
215     HTRANSFORM handle;
216
217     EnterCriticalSection( &MSCMS_handle_cs );
218
219     if ((handle = alloc_transform_handle()))
220     {
221         DWORD_PTR index = (DWORD_PTR)handle - 1;
222         memcpy( &transformtable[index], transform, sizeof(struct transform) );
223     }
224     LeaveCriticalSection( &MSCMS_handle_cs );
225     return handle;
226 }
227
228 BOOL close_transform( HTRANSFORM handle )
229 {
230     DWORD_PTR index;
231     struct transform *transform;
232
233     EnterCriticalSection( &MSCMS_handle_cs );
234
235     index = (DWORD_PTR)handle - 1;
236     if (index > num_transform_handles)
237     {
238         LeaveCriticalSection( &MSCMS_handle_cs );
239         return FALSE;
240     }
241     transform = &transformtable[index];
242
243     cmsDeleteTransform( transform->cmstransform );
244     memset( transform, 0, sizeof(struct transform) );
245
246     LeaveCriticalSection( &MSCMS_handle_cs );
247     return TRUE;
248 }
249
250 #endif /* HAVE_LCMS */