windows/property.c

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