windows/property.c

   1 /*
   2  * Window properties
   3  *
   4  * Copyright 1995, 1996 Alexandre Julliard
   5  */
   6
   7 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include "win.h"
  11 #include "heap.h"
  12 #include "string32.h"
  13 #include "stddebug.h"
  14 #include "debug.h"
  15
  16
  17 typedef struct tagPROPERTY
  18 {
  19     struct tagPROPERTY *next;     /* Next property in window list */
  20     HANDLE32            handle;   /* User's data */
  21     LPSTR               string;   /* Property string (or atom) */
  22 } PROPERTY;
  23
  24
  25 /***********************************************************************
  26  *           PROP_FindProp
  27  */
  28 static PROPERTY *PROP_FindProp( HWND32 hwnd, LPCSTR str )
  29 {
  30     PROPERTY *prop;
  31     WND *pWnd = WIN_FindWndPtr( hwnd );
  32
  33     if (!pWnd) return NULL;
  34     if (HIWORD(str))
  35     {
  36         for (prop = pWnd->pProp; prop; prop = prop->next)
  37             if (HIWORD(prop->string) && !lstrcmpi32A( prop->string, str ))
  38                 return prop;
  39     }
  40     else  /* atom */
  41     {
  42         for (prop = pWnd->pProp; (prop); prop = prop->next)
  43             if (!HIWORD(prop->string) && (LOWORD(prop->string) == LOWORD(str)))
  44                 return prop;
  45     }
  46     return NULL;
  47 }
  48
  49
  50 /***********************************************************************
  51  *           GetProp16   (USER.25)
  52  */
  53 HANDLE16 GetProp16( HWND16 hwnd, LPCSTR str )
  54 {
  55     return (HANDLE16)GetProp32A( hwnd, str );
  56 }
  57
  58
  59 /***********************************************************************
  60  *           GetProp32A   (USER32.280)
  61  */
  62 HANDLE32 GetProp32A( HWND32 hwnd, LPCSTR str )
  63 {
  64     PROPERTY *prop = PROP_FindProp( hwnd, str );
  65
  66     if (HIWORD(str))
  67         dprintf_prop( stddeb, "GetProp(%08x,'%s'): returning %08x\n",
  68                       hwnd, str, prop ? prop->handle : 0 );
  69     else
  70         dprintf_prop( stddeb, "GetProp(%08x,#%04x): returning %08x\n",
  71                       hwnd, LOWORD(str), prop ? prop->handle : 0 );
  72
  73     return prop ? prop->handle : 0;
  74 }
  75
  76
  77 /***********************************************************************
  78  *           GetProp32W   (USER32.281)
  79  */
  80 HANDLE32 GetProp32W( HWND32 hwnd, LPCWSTR str )
  81 {
  82     LPSTR strA;
  83     HANDLE32 ret;
  84
  85     if (!HIWORD(str)) return GetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
  86     strA = STRING32_DupUniToAnsi( str );
  87     ret = GetProp32A( hwnd, strA );
  88     free( strA );
  89     return ret;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           SetProp16   (USER.26)
  95  */
  96 BOOL16 SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
  97 {
  98     return (BOOL16)SetProp32A( hwnd, str, handle );
  99 }
 100
 101
 102 /***********************************************************************
 103  *           SetProp32A   (USER32.496)
 104  */
 105 BOOL32 SetProp32A( HWND32 hwnd, LPCSTR str, HANDLE32 handle )
 106 {
 107     PROPERTY *prop;
 108
 109     if (HIWORD(str))
 110         dprintf_prop( stddeb, "SetProp: %04x '%s' %08x\n", hwnd, str, handle );
 111     else
 112         dprintf_prop( stddeb, "SetProp: %04x #%04x %08x\n",
 113                       hwnd, LOWORD(str), handle );
 114
 115     if (!(prop = PROP_FindProp( hwnd, str )))
 116     {
 117         /* We need to create it */
 118         WND *pWnd = WIN_FindWndPtr( hwnd );
 119         if (!pWnd) return FALSE;
 120         if (!(prop = HeapAlloc( SystemHeap, 0, sizeof(*prop) ))) return FALSE;
 121         if (!(prop->string = SEGPTR_STRDUP(str)))
 122         {
 123             HeapFree( SystemHeap, 0, prop );
 124             return FALSE;
 125         }
 126         prop->next  = pWnd->pProp;
 127         pWnd->pProp = prop;
 128     }
 129     prop->handle = handle;
 130     return TRUE;
 131 }
 132
 133
 134 /***********************************************************************
 135  *           SetProp32W   (USER32.497)
 136  */
 137 BOOL32 SetProp32W( HWND32 hwnd, LPCWSTR str, HANDLE32 handle )
 138 {
 139     BOOL32 ret;
 140     LPSTR strA;
 141
 142     if (!HIWORD(str))
 143         return SetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str), handle );
 144     strA = STRING32_DupUniToAnsi( str );
 145     ret = SetProp32A( hwnd, strA, handle );
 146     free( strA );
 147     return ret;
 148 }
 149
 150
 151 /***********************************************************************
 152  *           RemoveProp16   (USER.24)
 153  */
 154 HANDLE16 RemoveProp16( HWND16 hwnd, LPCSTR str )
 155 {
 156     return (HANDLE16)RemoveProp32A( hwnd, str );
 157 }
 158
 159
 160 /***********************************************************************
 161  *           RemoveProp32A   (USER32.441)
 162  */
 163 HANDLE32 RemoveProp32A( HWND32 hwnd, LPCSTR str )
 164 {
 165     HANDLE32 handle;
 166     PROPERTY **pprop, *prop;
 167     WND *pWnd = WIN_FindWndPtr( hwnd );
 168
 169     if (HIWORD(str))
 170       dprintf_prop( stddeb, "RemoveProp: %04x '%s'\n", hwnd, str );
 171     else
 172       dprintf_prop( stddeb, "RemoveProp: %04x #%04x\n", hwnd, LOWORD(str));
 173
 174
 175     if (!pWnd) return NULL;
 176     if (HIWORD(str))
 177     {
 178         for (pprop=(PROPERTY**)&pWnd->pProp; (*pprop); pprop = &(*pprop)->next)
 179             if (HIWORD((*pprop)->string) &&
 180                 !lstrcmpi32A( (*pprop)->string, str )) break;
 181     }
 182     else  /* atom */
 183     {
 184         for (pprop=(PROPERTY**)&pWnd->pProp; (*pprop); pprop = &(*pprop)->next)
 185             if (!HIWORD((*pprop)->string) &&
 186                 (LOWORD((*pprop)->string) == LOWORD(str))) break;
 187     }
 188     if (!*pprop) return 0;
 189     prop   = *pprop;
 190     handle = prop->handle;
 191     *pprop = prop->next;
 192     SEGPTR_FREE(prop->string);
 193     HeapFree( SystemHeap, 0, prop );
 194     return handle;
 195 }
 196
 197
 198 /***********************************************************************
 199  *           RemoveProp32W   (USER32.442)
 200  */
 201 HANDLE32 RemoveProp32W( HWND32 hwnd, LPCWSTR str )
 202 {
 203     LPSTR strA;
 204     HANDLE32 ret;
 205
 206     if (!HIWORD(str))
 207         return RemoveProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
 208     strA = STRING32_DupUniToAnsi( str );
 209     ret = RemoveProp32A( hwnd, strA );
 210     free( strA );
 211     return ret;
 212 }
 213
 214
 215 /***********************************************************************
 216  *           PROPERTY_RemoveWindowProps
 217  *
 218  * Remove all properties of a window.
 219  */
 220 void PROPERTY_RemoveWindowProps( WND *pWnd )
 221 {
 222     PROPERTY *prop, *next;
 223
 224     for (prop = pWnd->pProp; (prop); prop = next)
 225     {
 226         next = prop->next;
 227         SEGPTR_FREE( prop->string );
 228         HeapFree( SystemHeap, 0, prop );
 229     }
 230     pWnd->pProp = NULL;
 231 }
 232
 233
 234 /***********************************************************************
 235  *           EnumProps16   (USER.27)
 236  */
 237 INT16 EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 238 {
 239     PROPERTY *prop, *next;
 240     WND *pWnd;
 241     INT16 ret = -1;
 242
 243     dprintf_prop( stddeb, "EnumProps: %04x %08x\n", hwnd, (UINT32)func );
 244     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 245     for (prop = pWnd->pProp; (prop); prop = next)
 246     {
 247         /* Already get the next in case the callback */
 248         /* function removes the current property.    */
 249         next = prop->next;
 250
 251         dprintf_prop( stddeb, "  Callback: handle=%08x str='%s'\n",
 252                       prop->handle, prop->string );
 253         ret = func( hwnd, SEGPTR_GET(prop->string), prop->handle );
 254         if (!ret) break;
 255     }
 256     return ret;
 257 }
 258
 259
 260 /***********************************************************************
 261  *           EnumProps32A   (USER32.185)
 262  */
 263 INT32 EnumProps32A( HWND32 hwnd, PROPENUMPROC32A func )
 264 {
 265     return EnumPropsEx32A( hwnd, (PROPENUMPROCEX32A)func, 0 );
 266 }
 267
 268
 269 /***********************************************************************
 270  *           EnumProps32W   (USER32.188)
 271  */
 272 INT32 EnumProps32W( HWND32 hwnd, PROPENUMPROC32W func )
 273 {
 274     return EnumPropsEx32W( hwnd, (PROPENUMPROCEX32W)func, 0 );
 275 }
 276
 277
 278 /***********************************************************************
 279  *           EnumPropsEx32A   (USER32.186)
 280  */
 281 INT32 EnumPropsEx32A( HWND32 hwnd, PROPENUMPROCEX32A func, LPARAM lParam )
 282 {
 283     PROPERTY *prop, *next;
 284     WND *pWnd;
 285     INT32 ret = -1;
 286
 287     dprintf_prop( stddeb, "EnumPropsEx32A: %04x %08x %08lx\n",
 288                   hwnd, (UINT32)func, lParam );
 289     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 290     for (prop = pWnd->pProp; (prop); prop = next)
 291     {
 292         /* Already get the next in case the callback */
 293         /* function removes the current property.    */
 294         next = prop->next;
 295
 296         dprintf_prop( stddeb, "  Callback: handle=%08x str='%s'\n",
 297                       prop->handle, prop->string );
 298         ret = func( hwnd, prop->string, prop->handle, lParam );
 299         if (!ret) break;
 300     }
 301     return ret;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           EnumPropsEx32W   (USER32.187)
 307  */
 308 INT32 EnumPropsEx32W( HWND32 hwnd, PROPENUMPROCEX32W func, LPARAM lParam )
 309 {
 310     PROPERTY *prop, *next;
 311     WND *pWnd;
 312     INT32 ret = -1;
 313
 314     dprintf_prop( stddeb, "EnumPropsEx32W: %04x %08x %08lx\n",
 315                   hwnd, (UINT32)func, lParam );
 316     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 317     for (prop = pWnd->pProp; (prop); prop = next)
 318     {
 319         /* Already get the next in case the callback */
 320         /* function removes the current property.    */
 321         next = prop->next;
 322
 323         dprintf_prop( stddeb, "  Callback: handle=%08x str='%s'\n",
 324                       prop->handle, prop->string );
 325         if (HIWORD(prop->string))
 326         {
 327             LPWSTR str = STRING32_DupAnsiToUni( prop->string );
 328             ret = func( hwnd, str, prop->handle, lParam );
 329             free( str );
 330         }
 331         else
 332             ret = func( hwnd, (LPCWSTR)(UINT32)LOWORD( prop->string ),
 333                         prop->handle, lParam );
 334         if (!ret) break;
 335     }
 336     return ret;
 337 }