Draw +/- correctly for large icon sizes.
[wine] / server / user.c
1 /*
2  * Server-side USER handles
3  *
4  * Copyright (C) 2001 Alexandre Julliard
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "thread.h"
22 #include "user.h"
23
24 struct user_handle
25 {
26     void          *ptr;          /* pointer to object */
27     unsigned short type;         /* object type (0 if free) */
28     unsigned short generation;   /* generation counter */
29 };
30
31 static struct user_handle *handles;
32 static struct user_handle *freelist;
33 static int nb_handles;
34 static int allocated_handles;
35
36 static struct user_handle *handle_to_entry( user_handle_t handle )
37 {
38     int index = (((unsigned int)handle & 0xffff) - FIRST_USER_HANDLE) >> 1;
39     if (index < 0 || index >= nb_handles) return NULL;
40     if (!handles[index].type) return NULL;
41     if (((unsigned int)handle >> 16) && ((unsigned int)handle >> 16 != handles[index].generation))
42         return NULL;
43     return &handles[index];
44 }
45
46 inline static user_handle_t entry_to_handle( struct user_handle *ptr )
47 {
48     int index = ptr - handles;
49     return (user_handle_t)(((index << 1) + FIRST_USER_HANDLE) + (ptr->generation << 16));
50 }
51
52 inline static struct user_handle *alloc_user_entry(void)
53 {
54     struct user_handle *handle;
55
56     if (freelist)
57     {
58         handle = freelist;
59         freelist = handle->ptr;
60         return handle;
61     }
62     if (nb_handles >= allocated_handles)  /* need to grow the array */
63     {
64         struct user_handle *new_handles;
65         /* grow array by 50% (but at minimum 32 entries) */
66         int growth = max( 32, allocated_handles / 2 );
67         int new_size = min( allocated_handles + growth, (LAST_USER_HANDLE-FIRST_USER_HANDLE+1) >> 1 );
68         if (new_size <= allocated_handles) return NULL;
69         if (!(new_handles = realloc( handles, new_size * sizeof(*handles) )))
70             return NULL;
71         handles = new_handles;
72         allocated_handles = new_size;
73     }
74     handle = &handles[nb_handles++];
75     handle->generation = 0;
76     return handle;
77 }
78
79 inline static void *free_user_entry( struct user_handle *ptr )
80 {
81     void *ret;
82     ret = ptr->ptr;
83     ptr->ptr  = freelist;
84     ptr->type = 0;
85     freelist  = ptr;
86     return ret;
87 }
88
89 /* allocate a user handle for a given object */
90 user_handle_t alloc_user_handle( void *ptr, enum user_object type )
91 {
92     struct user_handle *entry = alloc_user_entry();
93     if (!entry) return 0;
94     entry->ptr  = ptr;
95     entry->type = type;
96     if (++entry->generation >= 0xffff) entry->generation = 1;
97     return entry_to_handle( entry );
98 }
99
100 /* return a pointer to a user object from its handle */
101 void *get_user_object( user_handle_t handle, enum user_object type )
102 {
103     struct user_handle *entry;
104
105     if (!(entry = handle_to_entry( handle )) || entry->type != type) return NULL;
106     return entry->ptr;
107 }
108
109 /* get the full handle for a possibly truncated handle */
110 user_handle_t get_user_full_handle( user_handle_t handle )
111 {
112     struct user_handle *entry;
113
114     if ((unsigned int)handle >> 16) return handle;
115     if (!(entry = handle_to_entry( handle ))) return handle;
116     return entry_to_handle( entry );
117 }
118
119 /* same as get_user_object plus set the handle to the full 32-bit value */
120 void *get_user_object_handle( user_handle_t *handle, enum user_object type )
121 {
122     struct user_handle *entry;
123
124     if (!(entry = handle_to_entry( *handle )) || entry->type != type) return NULL;
125     *handle = entry_to_handle( entry );
126     return entry->ptr;
127 }
128
129 /* free a user handle and return a pointer to the object */
130 void *free_user_handle( user_handle_t handle )
131 {
132     struct user_handle *entry;
133
134     if (!(entry = handle_to_entry( handle )))
135     {
136         set_error( STATUS_INVALID_HANDLE );
137         return NULL;
138     }
139     return free_user_entry( entry );
140 }
141
142 /* return the next user handle after 'handle' that is of a given type */
143 void *next_user_handle( user_handle_t *handle, enum user_object type )
144 {
145     struct user_handle *entry;
146
147     if (!*handle) entry = handles;
148     else
149     {
150         int index = (((unsigned int)*handle & 0xffff) - FIRST_USER_HANDLE) >> 1;
151         if (index < 0 || index >= nb_handles) return NULL;
152         entry = handles + index + 1;  /* start from the next one */
153     }
154     while (entry < handles + nb_handles)
155     {
156         if (!type || entry->type == type)
157         {
158             *handle = entry_to_handle( entry );
159             return entry->ptr;
160         }
161         entry++;
162     }
163     return NULL;
164 }